home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Magazine / Morphos / GCC / ppc-amigaos / include / powerup / ppcpragmas / graphics_pragmas.h < prev    next >
C/C++ Source or Header  |  2000-02-28  |  94KB  |  3,271 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_GRAPHICS_H
  4. #define _PPCPRAGMA_GRAPHICS_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__GRAPHICS_H
  7. #include <powerup/ppcinline/graphics.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef GRAPHICS_BASE_NAME
  24. #define GRAPHICS_BASE_NAME GfxBase
  25. #endif /* !GRAPHICS_BASE_NAME */
  26.  
  27. #define    AddAnimOb(anOb, anKey, rp)    _AddAnimOb(GRAPHICS_BASE_NAME, anOb, anKey, rp)
  28.  
  29. static __inline void
  30. _AddAnimOb(void *GfxBase, struct AnimOb *anOb, struct AnimOb **anKey, struct RastPort *rp)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) anOb;
  40.     MyCaos.a1        =(ULONG) anKey;
  41.     MyCaos.a2        =(ULONG) rp;
  42.     MyCaos.caos_Un.Offset    =    (-156);
  43.     MyCaos.a6        =(ULONG) GfxBase;    
  44.     PPCCallOS(&MyCaos);
  45. }
  46.  
  47. #define    AddBob(bob, rp)    _AddBob(GRAPHICS_BASE_NAME, bob, rp)
  48.  
  49. static __inline void
  50. _AddBob(void *GfxBase, struct Bob *bob, struct RastPort *rp)
  51. {
  52. struct Caos    MyCaos;
  53.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  54. //    MyCaos.M68kStart    =    NULL;
  55. //    MyCaos.M68kSize        =    0;
  56.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  57. //    MyCaos.PPCStart        =    NULL;
  58. //    MyCaos.PPCSize        =    0;
  59.     MyCaos.a0        =(ULONG) bob;
  60.     MyCaos.a1        =(ULONG) rp;
  61.     MyCaos.caos_Un.Offset    =    (-96);
  62.     MyCaos.a6        =(ULONG) GfxBase;    
  63.     PPCCallOS(&MyCaos);
  64. }
  65.  
  66. #define    AddFont(textFont)    _AddFont(GRAPHICS_BASE_NAME, textFont)
  67.  
  68. static __inline void
  69. _AddFont(void *GfxBase, struct TextFont *textFont)
  70. {
  71. struct Caos    MyCaos;
  72.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  73. //    MyCaos.M68kStart    =    NULL;
  74. //    MyCaos.M68kSize        =    0;
  75.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  76. //    MyCaos.PPCStart        =    NULL;
  77. //    MyCaos.PPCSize        =    0;
  78.     MyCaos.a1        =(ULONG) textFont;
  79.     MyCaos.caos_Un.Offset    =    (-480);
  80.     MyCaos.a6        =(ULONG) GfxBase;    
  81.     PPCCallOS(&MyCaos);
  82. }
  83.  
  84. #define    AddVSprite(vSprite, rp)    _AddVSprite(GRAPHICS_BASE_NAME, vSprite, rp)
  85.  
  86. static __inline void
  87. _AddVSprite(void *GfxBase, struct VSprite *vSprite, struct RastPort *rp)
  88. {
  89. struct Caos    MyCaos;
  90.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  91. //    MyCaos.M68kStart    =    NULL;
  92. //    MyCaos.M68kSize        =    0;
  93.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  94. //    MyCaos.PPCStart        =    NULL;
  95. //    MyCaos.PPCSize        =    0;
  96.     MyCaos.a0        =(ULONG) vSprite;
  97.     MyCaos.a1        =(ULONG) rp;
  98.     MyCaos.caos_Un.Offset    =    (-102);
  99.     MyCaos.a6        =(ULONG) GfxBase;    
  100.     PPCCallOS(&MyCaos);
  101. }
  102.  
  103. #define    AllocBitMap(sizex, sizey, depth, flags, friend_bitmap)    _AllocBitMap(GRAPHICS_BASE_NAME, sizex, sizey, depth, flags, friend_bitmap)
  104.  
  105. static __inline struct BitMap *
  106. _AllocBitMap(void *GfxBase, unsigned long sizex, unsigned long sizey, unsigned long depth, unsigned long flags, struct BitMap *friend_bitmap)
  107. {
  108. struct Caos    MyCaos;
  109.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  110. //    MyCaos.M68kStart    =    NULL;
  111. //    MyCaos.M68kSize        =    0;
  112.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  113. //    MyCaos.PPCStart        =    NULL;
  114. //    MyCaos.PPCSize        =    0;
  115.     MyCaos.d0        =(ULONG) sizex;
  116.     MyCaos.d1        =(ULONG) sizey;
  117.     MyCaos.d2        =(ULONG) depth;
  118.     MyCaos.d3        =(ULONG) flags;
  119.     MyCaos.a0        =(ULONG) friend_bitmap;
  120.     MyCaos.caos_Un.Offset    =    (-918);
  121.     MyCaos.a6        =(ULONG) GfxBase;    
  122.     return((struct BitMap *)PPCCallOS(&MyCaos));
  123. }
  124.  
  125. #define    AllocDBufInfo(vp)    _AllocDBufInfo(GRAPHICS_BASE_NAME, vp)
  126.  
  127. static __inline struct DBufInfo *
  128. _AllocDBufInfo(void *GfxBase, struct ViewPort *vp)
  129. {
  130. struct Caos    MyCaos;
  131.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  132. //    MyCaos.M68kStart    =    NULL;
  133. //    MyCaos.M68kSize        =    0;
  134.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  135. //    MyCaos.PPCStart        =    NULL;
  136. //    MyCaos.PPCSize        =    0;
  137.     MyCaos.a0        =(ULONG) vp;
  138.     MyCaos.caos_Un.Offset    =    (-966);
  139.     MyCaos.a6        =(ULONG) GfxBase;    
  140.     return((struct DBufInfo *)PPCCallOS(&MyCaos));
  141. }
  142.  
  143. #define    AllocRaster(width, height)    _AllocRaster(GRAPHICS_BASE_NAME, width, height)
  144.  
  145. static __inline PLANEPTR
  146. _AllocRaster(void *GfxBase, unsigned long width, unsigned long height)
  147. {
  148. struct Caos    MyCaos;
  149.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  150. //    MyCaos.M68kStart    =    NULL;
  151. //    MyCaos.M68kSize        =    0;
  152.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  153. //    MyCaos.PPCStart        =    NULL;
  154. //    MyCaos.PPCSize        =    0;
  155.     MyCaos.d0        =(ULONG) width;
  156.     MyCaos.d1        =(ULONG) height;
  157.     MyCaos.caos_Un.Offset    =    (-492);
  158.     MyCaos.a6        =(ULONG) GfxBase;    
  159.     return((PLANEPTR)PPCCallOS(&MyCaos));
  160. }
  161.  
  162. #define    AllocSpriteDataA(bm, tags)    _AllocSpriteDataA(GRAPHICS_BASE_NAME, bm, tags)
  163.  
  164. static __inline struct ExtSprite *
  165. _AllocSpriteDataA(void *GfxBase, struct BitMap *bm, struct TagItem *tags)
  166. {
  167. struct Caos    MyCaos;
  168.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  169. //    MyCaos.M68kStart    =    NULL;
  170. //    MyCaos.M68kSize        =    0;
  171.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  172. //    MyCaos.PPCStart        =    NULL;
  173. //    MyCaos.PPCSize        =    0;
  174.     MyCaos.a2        =(ULONG) bm;
  175.     MyCaos.a1        =(ULONG) tags;
  176.     MyCaos.caos_Un.Offset    =    (-1020);
  177.     MyCaos.a6        =(ULONG) GfxBase;    
  178.     return((struct ExtSprite *)PPCCallOS(&MyCaos));
  179. }
  180.  
  181. #ifndef NO_PPCINLINE_STDARG
  182. #define AllocSpriteData(a0, tags...) \
  183.     ({ULONG _tags[] = { tags }; AllocSpriteDataA((a0), (struct TagItem *)_tags);})
  184. #endif /* !NO_PPCINLINE_STDARG */
  185.  
  186. #define    AndRectRegion(region, rectangle)    _AndRectRegion(GRAPHICS_BASE_NAME, region, rectangle)
  187.  
  188. static __inline void
  189. _AndRectRegion(void *GfxBase, struct Region *region, struct Rectangle *rectangle)
  190. {
  191. struct Caos    MyCaos;
  192.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  193. //    MyCaos.M68kStart    =    NULL;
  194. //    MyCaos.M68kSize        =    0;
  195.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  196. //    MyCaos.PPCStart        =    NULL;
  197. //    MyCaos.PPCSize        =    0;
  198.     MyCaos.a0        =(ULONG) region;
  199.     MyCaos.a1        =(ULONG) rectangle;
  200.     MyCaos.caos_Un.Offset    =    (-504);
  201.     MyCaos.a6        =(ULONG) GfxBase;    
  202.     PPCCallOS(&MyCaos);
  203. }
  204.  
  205. #define    AndRegionRegion(srcRegion, destRegion)    _AndRegionRegion(GRAPHICS_BASE_NAME, srcRegion, destRegion)
  206.  
  207. static __inline BOOL
  208. _AndRegionRegion(void *GfxBase, struct Region *srcRegion, struct Region *destRegion)
  209. {
  210. struct Caos    MyCaos;
  211.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  212. //    MyCaos.M68kStart    =    NULL;
  213. //    MyCaos.M68kSize        =    0;
  214.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  215. //    MyCaos.PPCStart        =    NULL;
  216. //    MyCaos.PPCSize        =    0;
  217.     MyCaos.a0        =(ULONG) srcRegion;
  218.     MyCaos.a1        =(ULONG) destRegion;
  219.     MyCaos.caos_Un.Offset    =    (-624);
  220.     MyCaos.a6        =(ULONG) GfxBase;    
  221.     return((BOOL)PPCCallOS(&MyCaos));
  222. }
  223.  
  224. #define    Animate(anKey, rp)    _Animate(GRAPHICS_BASE_NAME, anKey, rp)
  225.  
  226. static __inline void
  227. _Animate(void *GfxBase, struct AnimOb **anKey, struct RastPort *rp)
  228. {
  229. struct Caos    MyCaos;
  230.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  231. //    MyCaos.M68kStart    =    NULL;
  232. //    MyCaos.M68kSize        =    0;
  233.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  234. //    MyCaos.PPCStart        =    NULL;
  235. //    MyCaos.PPCSize        =    0;
  236.     MyCaos.a0        =(ULONG) anKey;
  237.     MyCaos.a1        =(ULONG) rp;
  238.     MyCaos.caos_Un.Offset    =    (-162);
  239.     MyCaos.a6        =(ULONG) GfxBase;    
  240.     PPCCallOS(&MyCaos);
  241. }
  242.  
  243. #define    AreaDraw(rp, x, y)    _AreaDraw(GRAPHICS_BASE_NAME, rp, x, y)
  244.  
  245. static __inline LONG
  246. _AreaDraw(void *GfxBase, struct RastPort *rp, long x, long y)
  247. {
  248. struct Caos    MyCaos;
  249.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  250. //    MyCaos.M68kStart    =    NULL;
  251. //    MyCaos.M68kSize        =    0;
  252.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  253. //    MyCaos.PPCStart        =    NULL;
  254. //    MyCaos.PPCSize        =    0;
  255.     MyCaos.a1        =(ULONG) rp;
  256.     MyCaos.d0        =(ULONG) x;
  257.     MyCaos.d1        =(ULONG) y;
  258.     MyCaos.caos_Un.Offset    =    (-258);
  259.     MyCaos.a6        =(ULONG) GfxBase;    
  260.     return((LONG)PPCCallOS(&MyCaos));
  261. }
  262.  
  263. #define    AreaEllipse(rp, xCenter, yCenter, a, b)    _AreaEllipse(GRAPHICS_BASE_NAME, rp, xCenter, yCenter, a, b)
  264.  
  265. static __inline LONG
  266. _AreaEllipse(void *GfxBase, struct RastPort *rp, long xCenter, long yCenter, long a, long b)
  267. {
  268. struct Caos    MyCaos;
  269.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  270. //    MyCaos.M68kStart    =    NULL;
  271. //    MyCaos.M68kSize        =    0;
  272.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  273. //    MyCaos.PPCStart        =    NULL;
  274. //    MyCaos.PPCSize        =    0;
  275.     MyCaos.a1        =(ULONG) rp;
  276.     MyCaos.d0        =(ULONG) xCenter;
  277.     MyCaos.d1        =(ULONG) yCenter;
  278.     MyCaos.d2        =(ULONG) a;
  279.     MyCaos.d3        =(ULONG) b;
  280.     MyCaos.caos_Un.Offset    =    (-186);
  281.     MyCaos.a6        =(ULONG) GfxBase;    
  282.     return((LONG)PPCCallOS(&MyCaos));
  283. }
  284.  
  285. #define    AreaEnd(rp)    _AreaEnd(GRAPHICS_BASE_NAME, rp)
  286.  
  287. static __inline LONG
  288. _AreaEnd(void *GfxBase, struct RastPort *rp)
  289. {
  290. struct Caos    MyCaos;
  291.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  292. //    MyCaos.M68kStart    =    NULL;
  293. //    MyCaos.M68kSize        =    0;
  294.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  295. //    MyCaos.PPCStart        =    NULL;
  296. //    MyCaos.PPCSize        =    0;
  297.     MyCaos.a1        =(ULONG) rp;
  298.     MyCaos.caos_Un.Offset    =    (-264);
  299.     MyCaos.a6        =(ULONG) GfxBase;    
  300.     return((LONG)PPCCallOS(&MyCaos));
  301. }
  302.  
  303. #define    AreaMove(rp, x, y)    _AreaMove(GRAPHICS_BASE_NAME, rp, x, y)
  304.  
  305. static __inline LONG
  306. _AreaMove(void *GfxBase, struct RastPort *rp, long x, long y)
  307. {
  308. struct Caos    MyCaos;
  309.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  310. //    MyCaos.M68kStart    =    NULL;
  311. //    MyCaos.M68kSize        =    0;
  312.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  313. //    MyCaos.PPCStart        =    NULL;
  314. //    MyCaos.PPCSize        =    0;
  315.     MyCaos.a1        =(ULONG) rp;
  316.     MyCaos.d0        =(ULONG) x;
  317.     MyCaos.d1        =(ULONG) y;
  318.     MyCaos.caos_Un.Offset    =    (-252);
  319.     MyCaos.a6        =(ULONG) GfxBase;    
  320.     return((LONG)PPCCallOS(&MyCaos));
  321. }
  322.  
  323. #define    AskFont(rp, textAttr)    _AskFont(GRAPHICS_BASE_NAME, rp, textAttr)
  324.  
  325. static __inline void
  326. _AskFont(void *GfxBase, struct RastPort *rp, struct TextAttr *textAttr)
  327. {
  328. struct Caos    MyCaos;
  329.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  330. //    MyCaos.M68kStart    =    NULL;
  331. //    MyCaos.M68kSize        =    0;
  332.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  333. //    MyCaos.PPCStart        =    NULL;
  334. //    MyCaos.PPCSize        =    0;
  335.     MyCaos.a1        =(ULONG) rp;
  336.     MyCaos.a0        =(ULONG) textAttr;
  337.     MyCaos.caos_Un.Offset    =    (-474);
  338.     MyCaos.a6        =(ULONG) GfxBase;    
  339.     PPCCallOS(&MyCaos);
  340. }
  341.  
  342. #define    AskSoftStyle(rp)    _AskSoftStyle(GRAPHICS_BASE_NAME, rp)
  343.  
  344. static __inline ULONG
  345. _AskSoftStyle(void *GfxBase, struct RastPort *rp)
  346. {
  347. struct Caos    MyCaos;
  348.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  349. //    MyCaos.M68kStart    =    NULL;
  350. //    MyCaos.M68kSize        =    0;
  351.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  352. //    MyCaos.PPCStart        =    NULL;
  353. //    MyCaos.PPCSize        =    0;
  354.     MyCaos.a1        =(ULONG) rp;
  355.     MyCaos.caos_Un.Offset    =    (-84);
  356.     MyCaos.a6        =(ULONG) GfxBase;    
  357.     return((ULONG)PPCCallOS(&MyCaos));
  358. }
  359.  
  360. #define    AttachPalExtra(cm, vp)    _AttachPalExtra(GRAPHICS_BASE_NAME, cm, vp)
  361.  
  362. static __inline LONG
  363. _AttachPalExtra(void *GfxBase, struct ColorMap *cm, struct ViewPort *vp)
  364. {
  365. struct Caos    MyCaos;
  366.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  367. //    MyCaos.M68kStart    =    NULL;
  368. //    MyCaos.M68kSize        =    0;
  369.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  370. //    MyCaos.PPCStart        =    NULL;
  371. //    MyCaos.PPCSize        =    0;
  372.     MyCaos.a0        =(ULONG) cm;
  373.     MyCaos.a1        =(ULONG) vp;
  374.     MyCaos.caos_Un.Offset    =    (-834);
  375.     MyCaos.a6        =(ULONG) GfxBase;    
  376.     return((LONG)PPCCallOS(&MyCaos));
  377. }
  378.  
  379. #define    AttemptLockLayerRom(layer)    _AttemptLockLayerRom(GRAPHICS_BASE_NAME, layer)
  380.  
  381. static __inline BOOL
  382. _AttemptLockLayerRom(void *GfxBase, struct Layer *layer)
  383. {
  384. struct Caos    MyCaos;
  385.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  386. //    MyCaos.M68kStart    =    NULL;
  387. //    MyCaos.M68kSize        =    0;
  388.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  389. //    MyCaos.PPCStart        =    NULL;
  390. //    MyCaos.PPCSize        =    0;
  391.     MyCaos.a5        =(ULONG) layer;
  392.     MyCaos.caos_Un.Offset    =    (-654);
  393.     MyCaos.a6        =(ULONG) GfxBase;    
  394.     return((BOOL)PPCCallOS(&MyCaos));
  395. }
  396.  
  397. #define    BestModeIDA(tags)    _BestModeIDA(GRAPHICS_BASE_NAME, tags)
  398.  
  399. static __inline ULONG
  400. _BestModeIDA(void *GfxBase, struct TagItem *tags)
  401. {
  402. struct Caos    MyCaos;
  403.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  404. //    MyCaos.M68kStart    =    NULL;
  405. //    MyCaos.M68kSize        =    0;
  406.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  407. //    MyCaos.PPCStart        =    NULL;
  408. //    MyCaos.PPCSize        =    0;
  409.     MyCaos.a0        =(ULONG) tags;
  410.     MyCaos.caos_Un.Offset    =    (-1050);
  411.     MyCaos.a6        =(ULONG) GfxBase;    
  412.     return((ULONG)PPCCallOS(&MyCaos));
  413. }
  414.  
  415. #ifndef NO_PPCINLINE_STDARG
  416. #define BestModeID(tags...) \
  417.     ({ULONG _tags[] = { tags }; BestModeIDA((struct TagItem *)_tags);})
  418. #endif /* !NO_PPCINLINE_STDARG */
  419.  
  420. #define    BitMapScale(bitScaleArgs)    _BitMapScale(GRAPHICS_BASE_NAME, bitScaleArgs)
  421.  
  422. static __inline void
  423. _BitMapScale(void *GfxBase, struct BitScaleArgs *bitScaleArgs)
  424. {
  425. struct Caos    MyCaos;
  426.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  427. //    MyCaos.M68kStart    =    NULL;
  428. //    MyCaos.M68kSize        =    0;
  429.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  430. //    MyCaos.PPCStart        =    NULL;
  431. //    MyCaos.PPCSize        =    0;
  432.     MyCaos.a0        =(ULONG) bitScaleArgs;
  433.     MyCaos.caos_Un.Offset    =    (-678);
  434.     MyCaos.a6        =(ULONG) GfxBase;    
  435.     PPCCallOS(&MyCaos);
  436. }
  437.  
  438. #define    BltBitMap(srcBitMap, xSrc, ySrc, destBitMap, xDest, yDest, xSize, ySize, minterm, mask, tempA)    _BltBitMap(GRAPHICS_BASE_NAME, srcBitMap, xSrc, ySrc, destBitMap, xDest, yDest, xSize, ySize, minterm, mask, tempA)
  439.  
  440. static __inline LONG
  441. _BltBitMap(void *GfxBase, struct BitMap *srcBitMap, long xSrc, long ySrc, struct BitMap *destBitMap, long xDest, long yDest, long xSize, long ySize, unsigned long minterm, unsigned long mask, PLANEPTR tempA)
  442. {
  443. struct Caos    MyCaos;
  444.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  445. //    MyCaos.M68kStart    =    NULL;
  446. //    MyCaos.M68kSize        =    0;
  447.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  448. //    MyCaos.PPCStart        =    NULL;
  449. //    MyCaos.PPCSize        =    0;
  450.     MyCaos.a0        =(ULONG) srcBitMap;
  451.     MyCaos.d0        =(ULONG) xSrc;
  452.     MyCaos.d1        =(ULONG) ySrc;
  453.     MyCaos.a1        =(ULONG) destBitMap;
  454.     MyCaos.d2        =(ULONG) xDest;
  455.     MyCaos.d3        =(ULONG) yDest;
  456.     MyCaos.d4        =(ULONG) xSize;
  457.     MyCaos.d5        =(ULONG) ySize;
  458.     MyCaos.d6        =(ULONG) minterm;
  459.     MyCaos.d7        =(ULONG) mask;
  460.     MyCaos.a2        =(ULONG) tempA;
  461.     MyCaos.caos_Un.Offset    =    (-30);
  462.     MyCaos.a6        =(ULONG) GfxBase;    
  463.     return((LONG)PPCCallOS(&MyCaos));
  464. }
  465.  
  466. #define    BltBitMapRastPort(srcBitMap, xSrc, ySrc, destRP, xDest, yDest, xSize, ySize, minterm)    _BltBitMapRastPort(GRAPHICS_BASE_NAME, srcBitMap, xSrc, ySrc, destRP, xDest, yDest, xSize, ySize, minterm)
  467.  
  468. static __inline void
  469. _BltBitMapRastPort(void *GfxBase, struct BitMap *srcBitMap, long xSrc, long ySrc, struct RastPort *destRP, long xDest, long yDest, long xSize, long ySize, unsigned long minterm)
  470. {
  471. struct Caos    MyCaos;
  472.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  473. //    MyCaos.M68kStart    =    NULL;
  474. //    MyCaos.M68kSize        =    0;
  475.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  476. //    MyCaos.PPCStart        =    NULL;
  477. //    MyCaos.PPCSize        =    0;
  478.     MyCaos.a0        =(ULONG) srcBitMap;
  479.     MyCaos.d0        =(ULONG) xSrc;
  480.     MyCaos.d1        =(ULONG) ySrc;
  481.     MyCaos.a1        =(ULONG) destRP;
  482.     MyCaos.d2        =(ULONG) xDest;
  483.     MyCaos.d3        =(ULONG) yDest;
  484.     MyCaos.d4        =(ULONG) xSize;
  485.     MyCaos.d5        =(ULONG) ySize;
  486.     MyCaos.d6        =(ULONG) minterm;
  487.     MyCaos.caos_Un.Offset    =    (-606);
  488.     MyCaos.a6        =(ULONG) GfxBase;    
  489.     PPCCallOS(&MyCaos);
  490. }
  491.  
  492. #define    BltClear(memBlock, byteCount, flags)    _BltClear(GRAPHICS_BASE_NAME, memBlock, byteCount, flags)
  493.  
  494. static __inline void
  495. _BltClear(void *GfxBase, PLANEPTR memBlock, unsigned long byteCount, unsigned long flags)
  496. {
  497. struct Caos    MyCaos;
  498.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  499. //    MyCaos.M68kStart    =    NULL;
  500. //    MyCaos.M68kSize        =    0;
  501.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  502. //    MyCaos.PPCStart        =    NULL;
  503. //    MyCaos.PPCSize        =    0;
  504.     MyCaos.a1        =(ULONG) memBlock;
  505.     MyCaos.d0        =(ULONG) byteCount;
  506.     MyCaos.d1        =(ULONG) flags;
  507.     MyCaos.caos_Un.Offset    =    (-300);
  508.     MyCaos.a6        =(ULONG) GfxBase;    
  509.     PPCCallOS(&MyCaos);
  510. }
  511.  
  512. #define    BltMaskBitMapRastPort(srcBitMap, xSrc, ySrc, destRP, xDest, yDest, xSize, ySize, minterm, bltMask)    _BltMaskBitMapRastPort(GRAPHICS_BASE_NAME, srcBitMap, xSrc, ySrc, destRP, xDest, yDest, xSize, ySize, minterm, bltMask)
  513.  
  514. static __inline void
  515. _BltMaskBitMapRastPort(void *GfxBase, struct BitMap *srcBitMap, long xSrc, long ySrc, struct RastPort *destRP, long xDest, long yDest, long xSize, long ySize, unsigned long minterm, PLANEPTR bltMask)
  516. {
  517. struct Caos    MyCaos;
  518.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  519. //    MyCaos.M68kStart    =    NULL;
  520. //    MyCaos.M68kSize        =    0;
  521.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  522. //    MyCaos.PPCStart        =    NULL;
  523. //    MyCaos.PPCSize        =    0;
  524.     MyCaos.a0        =(ULONG) srcBitMap;
  525.     MyCaos.d0        =(ULONG) xSrc;
  526.     MyCaos.d1        =(ULONG) ySrc;
  527.     MyCaos.a1        =(ULONG) destRP;
  528.     MyCaos.d2        =(ULONG) xDest;
  529.     MyCaos.d3        =(ULONG) yDest;
  530.     MyCaos.d4        =(ULONG) xSize;
  531.     MyCaos.d5        =(ULONG) ySize;
  532.     MyCaos.d6        =(ULONG) minterm;
  533.     MyCaos.a2        =(ULONG) bltMask;
  534.     MyCaos.caos_Un.Offset    =    (-636);
  535.     MyCaos.a6        =(ULONG) GfxBase;    
  536.     PPCCallOS(&MyCaos);
  537. }
  538.  
  539. #define    BltPattern(rp, mask, xMin, yMin, xMax, yMax, maskBPR)    _BltPattern(GRAPHICS_BASE_NAME, rp, mask, xMin, yMin, xMax, yMax, maskBPR)
  540.  
  541. static __inline void
  542. _BltPattern(void *GfxBase, struct RastPort *rp, PLANEPTR mask, long xMin, long yMin, long xMax, long yMax, unsigned long maskBPR)
  543. {
  544. struct Caos    MyCaos;
  545.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  546. //    MyCaos.M68kStart    =    NULL;
  547. //    MyCaos.M68kSize        =    0;
  548.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  549. //    MyCaos.PPCStart        =    NULL;
  550. //    MyCaos.PPCSize        =    0;
  551.     MyCaos.a1        =(ULONG) rp;
  552.     MyCaos.a0        =(ULONG) mask;
  553.     MyCaos.d0        =(ULONG) xMin;
  554.     MyCaos.d1        =(ULONG) yMin;
  555.     MyCaos.d2        =(ULONG) xMax;
  556.     MyCaos.d3        =(ULONG) yMax;
  557.     MyCaos.d4        =(ULONG) maskBPR;
  558.     MyCaos.caos_Un.Offset    =    (-312);
  559.     MyCaos.a6        =(ULONG) GfxBase;    
  560.     PPCCallOS(&MyCaos);
  561. }
  562.  
  563. #define    BltTemplate(source, xSrc, srcMod, destRP, xDest, yDest, xSize, ySize)    _BltTemplate(GRAPHICS_BASE_NAME, source, xSrc, srcMod, destRP, xDest, yDest, xSize, ySize)
  564.  
  565. static __inline void
  566. _BltTemplate(void *GfxBase, PLANEPTR source, long xSrc, long srcMod, struct RastPort *destRP, long xDest, long yDest, long xSize, long ySize)
  567. {
  568. struct Caos    MyCaos;
  569.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  570. //    MyCaos.M68kStart    =    NULL;
  571. //    MyCaos.M68kSize        =    0;
  572.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  573. //    MyCaos.PPCStart        =    NULL;
  574. //    MyCaos.PPCSize        =    0;
  575.     MyCaos.a0        =(ULONG) source;
  576.     MyCaos.d0        =(ULONG) xSrc;
  577.     MyCaos.d1        =(ULONG) srcMod;
  578.     MyCaos.a1        =(ULONG) destRP;
  579.     MyCaos.d2        =(ULONG) xDest;
  580.     MyCaos.d3        =(ULONG) yDest;
  581.     MyCaos.d4        =(ULONG) xSize;
  582.     MyCaos.d5        =(ULONG) ySize;
  583.     MyCaos.caos_Un.Offset    =    (-36);
  584.     MyCaos.a6        =(ULONG) GfxBase;    
  585.     PPCCallOS(&MyCaos);
  586. }
  587.  
  588. #define    CBump(copList)    _CBump(GRAPHICS_BASE_NAME, copList)
  589.  
  590. static __inline void
  591. _CBump(void *GfxBase, struct UCopList *copList)
  592. {
  593. struct Caos    MyCaos;
  594.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  595. //    MyCaos.M68kStart    =    NULL;
  596. //    MyCaos.M68kSize        =    0;
  597.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  598. //    MyCaos.PPCStart        =    NULL;
  599. //    MyCaos.PPCSize        =    0;
  600.     MyCaos.a1        =(ULONG) copList;
  601.     MyCaos.caos_Un.Offset    =    (-366);
  602.     MyCaos.a6        =(ULONG) GfxBase;    
  603.     PPCCallOS(&MyCaos);
  604. }
  605.  
  606. #define    CMove(copList, destination, data)    _CMove(GRAPHICS_BASE_NAME, copList, destination, data)
  607.  
  608. static __inline void
  609. _CMove(void *GfxBase, struct UCopList *copList, APTR destination, long data)
  610. {
  611. struct Caos    MyCaos;
  612.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  613. //    MyCaos.M68kStart    =    NULL;
  614. //    MyCaos.M68kSize        =    0;
  615.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  616. //    MyCaos.PPCStart        =    NULL;
  617. //    MyCaos.PPCSize        =    0;
  618.     MyCaos.a1        =(ULONG) copList;
  619.     MyCaos.d0        =(ULONG) destination;
  620.     MyCaos.d1        =(ULONG) data;
  621.     MyCaos.caos_Un.Offset    =    (-372);
  622.     MyCaos.a6        =(ULONG) GfxBase;    
  623.     PPCCallOS(&MyCaos);
  624. }
  625.  
  626. #define    CWait(copList, v, h)    _CWait(GRAPHICS_BASE_NAME, copList, v, h)
  627.  
  628. static __inline void
  629. _CWait(void *GfxBase, struct UCopList *copList, long v, long h)
  630. {
  631. struct Caos    MyCaos;
  632.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  633. //    MyCaos.M68kStart    =    NULL;
  634. //    MyCaos.M68kSize        =    0;
  635.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  636. //    MyCaos.PPCStart        =    NULL;
  637. //    MyCaos.PPCSize        =    0;
  638.     MyCaos.a1        =(ULONG) copList;
  639.     MyCaos.d0        =(ULONG) v;
  640.     MyCaos.d1        =(ULONG) h;
  641.     MyCaos.caos_Un.Offset    =    (-378);
  642.     MyCaos.a6        =(ULONG) GfxBase;    
  643.     PPCCallOS(&MyCaos);
  644. }
  645.  
  646. #define    CalcIVG(v, vp)    _CalcIVG(GRAPHICS_BASE_NAME, v, vp)
  647.  
  648. static __inline UWORD
  649. _CalcIVG(void *GfxBase, struct View *v, struct ViewPort *vp)
  650. {
  651. struct Caos    MyCaos;
  652.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  653. //    MyCaos.M68kStart    =    NULL;
  654. //    MyCaos.M68kSize        =    0;
  655.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  656. //    MyCaos.PPCStart        =    NULL;
  657. //    MyCaos.PPCSize        =    0;
  658.     MyCaos.a0        =(ULONG) v;
  659.     MyCaos.a1        =(ULONG) vp;
  660.     MyCaos.caos_Un.Offset    =    (-828);
  661.     MyCaos.a6        =(ULONG) GfxBase;    
  662.     return((UWORD)PPCCallOS(&MyCaos));
  663. }
  664.  
  665. #define    ChangeExtSpriteA(vp, oldsprite, newsprite, tags)    _ChangeExtSpriteA(GRAPHICS_BASE_NAME, vp, oldsprite, newsprite, tags)
  666.  
  667. static __inline LONG
  668. _ChangeExtSpriteA(void *GfxBase, struct ViewPort *vp, struct ExtSprite *oldsprite, struct ExtSprite *newsprite, struct TagItem *tags)
  669. {
  670. struct Caos    MyCaos;
  671.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  672. //    MyCaos.M68kStart    =    NULL;
  673. //    MyCaos.M68kSize        =    0;
  674.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  675. //    MyCaos.PPCStart        =    NULL;
  676. //    MyCaos.PPCSize        =    0;
  677.     MyCaos.a0        =(ULONG) vp;
  678.     MyCaos.a1        =(ULONG) oldsprite;
  679.     MyCaos.a2        =(ULONG) newsprite;
  680.     MyCaos.a3        =(ULONG) tags;
  681.     MyCaos.caos_Un.Offset    =    (-1026);
  682.     MyCaos.a6        =(ULONG) GfxBase;    
  683.     return((LONG)PPCCallOS(&MyCaos));
  684. }
  685.  
  686. #ifndef NO_PPCINLINE_STDARG
  687. #define ChangeExtSprite(a0, a1, a2, tags...) \
  688.     ({ULONG _tags[] = { tags }; ChangeExtSpriteA((a0), (a1), (a2), (struct TagItem *)_tags);})
  689. #endif /* !NO_PPCINLINE_STDARG */
  690.  
  691. #define    ChangeSprite(vp, sprite, newData)    _ChangeSprite(GRAPHICS_BASE_NAME, vp, sprite, newData)
  692.  
  693. static __inline void
  694. _ChangeSprite(void *GfxBase, struct ViewPort *vp, struct SimpleSprite *sprite, PLANEPTR newData)
  695. {
  696. struct Caos    MyCaos;
  697.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  698. //    MyCaos.M68kStart    =    NULL;
  699. //    MyCaos.M68kSize        =    0;
  700.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  701. //    MyCaos.PPCStart        =    NULL;
  702. //    MyCaos.PPCSize        =    0;
  703.     MyCaos.a0        =(ULONG) vp;
  704.     MyCaos.a1        =(ULONG) sprite;
  705.     MyCaos.a2        =(ULONG) newData;
  706.     MyCaos.caos_Un.Offset    =    (-420);
  707.     MyCaos.a6        =(ULONG) GfxBase;    
  708.     PPCCallOS(&MyCaos);
  709. }
  710.  
  711. #define    ChangeVPBitMap(vp, bm, db)    _ChangeVPBitMap(GRAPHICS_BASE_NAME, vp, bm, db)
  712.  
  713. static __inline void
  714. _ChangeVPBitMap(void *GfxBase, struct ViewPort *vp, struct BitMap *bm, struct DBufInfo *db)
  715. {
  716. struct Caos    MyCaos;
  717.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  718. //    MyCaos.M68kStart    =    NULL;
  719. //    MyCaos.M68kSize        =    0;
  720.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  721. //    MyCaos.PPCStart        =    NULL;
  722. //    MyCaos.PPCSize        =    0;
  723.     MyCaos.a0        =(ULONG) vp;
  724.     MyCaos.a1        =(ULONG) bm;
  725.     MyCaos.a2        =(ULONG) db;
  726.     MyCaos.caos_Un.Offset    =    (-942);
  727.     MyCaos.a6        =(ULONG) GfxBase;    
  728.     PPCCallOS(&MyCaos);
  729. }
  730.  
  731. #define    ClearEOL(rp)    _ClearEOL(GRAPHICS_BASE_NAME, rp)
  732.  
  733. static __inline void
  734. _ClearEOL(void *GfxBase, struct RastPort *rp)
  735. {
  736. struct Caos    MyCaos;
  737.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  738. //    MyCaos.M68kStart    =    NULL;
  739. //    MyCaos.M68kSize        =    0;
  740.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  741. //    MyCaos.PPCStart        =    NULL;
  742. //    MyCaos.PPCSize        =    0;
  743.     MyCaos.a1        =(ULONG) rp;
  744.     MyCaos.caos_Un.Offset    =    (-42);
  745.     MyCaos.a6        =(ULONG) GfxBase;    
  746.     PPCCallOS(&MyCaos);
  747. }
  748.  
  749. #define    ClearRectRegion(region, rectangle)    _ClearRectRegion(GRAPHICS_BASE_NAME, region, rectangle)
  750.  
  751. static __inline BOOL
  752. _ClearRectRegion(void *GfxBase, struct Region *region, struct Rectangle *rectangle)
  753. {
  754. struct Caos    MyCaos;
  755.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  756. //    MyCaos.M68kStart    =    NULL;
  757. //    MyCaos.M68kSize        =    0;
  758.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  759. //    MyCaos.PPCStart        =    NULL;
  760. //    MyCaos.PPCSize        =    0;
  761.     MyCaos.a0        =(ULONG) region;
  762.     MyCaos.a1        =(ULONG) rectangle;
  763.     MyCaos.caos_Un.Offset    =    (-522);
  764.     MyCaos.a6        =(ULONG) GfxBase;    
  765.     return((BOOL)PPCCallOS(&MyCaos));
  766. }
  767.  
  768. #define    ClearRegion(region)    _ClearRegion(GRAPHICS_BASE_NAME, region)
  769.  
  770. static __inline void
  771. _ClearRegion(void *GfxBase, struct Region *region)
  772. {
  773. struct Caos    MyCaos;
  774.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  775. //    MyCaos.M68kStart    =    NULL;
  776. //    MyCaos.M68kSize        =    0;
  777.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  778. //    MyCaos.PPCStart        =    NULL;
  779. //    MyCaos.PPCSize        =    0;
  780.     MyCaos.a0        =(ULONG) region;
  781.     MyCaos.caos_Un.Offset    =    (-528);
  782.     MyCaos.a6        =(ULONG) GfxBase;    
  783.     PPCCallOS(&MyCaos);
  784. }
  785.  
  786. #define    ClearScreen(rp)    _ClearScreen(GRAPHICS_BASE_NAME, rp)
  787.  
  788. static __inline void
  789. _ClearScreen(void *GfxBase, struct RastPort *rp)
  790. {
  791. struct Caos    MyCaos;
  792.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  793. //    MyCaos.M68kStart    =    NULL;
  794. //    MyCaos.M68kSize        =    0;
  795.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  796. //    MyCaos.PPCStart        =    NULL;
  797. //    MyCaos.PPCSize        =    0;
  798.     MyCaos.a1        =(ULONG) rp;
  799.     MyCaos.caos_Un.Offset    =    (-48);
  800.     MyCaos.a6        =(ULONG) GfxBase;    
  801.     PPCCallOS(&MyCaos);
  802. }
  803.  
  804. #define    ClipBlit(srcRP, xSrc, ySrc, destRP, xDest, yDest, xSize, ySize, minterm)    _ClipBlit(GRAPHICS_BASE_NAME, srcRP, xSrc, ySrc, destRP, xDest, yDest, xSize, ySize, minterm)
  805.  
  806. static __inline void
  807. _ClipBlit(void *GfxBase, struct RastPort *srcRP, long xSrc, long ySrc, struct RastPort *destRP, long xDest, long yDest, long xSize, long ySize, unsigned long minterm)
  808. {
  809. struct Caos    MyCaos;
  810.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  811. //    MyCaos.M68kStart    =    NULL;
  812. //    MyCaos.M68kSize        =    0;
  813.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  814. //    MyCaos.PPCStart        =    NULL;
  815. //    MyCaos.PPCSize        =    0;
  816.     MyCaos.a0        =(ULONG) srcRP;
  817.     MyCaos.d0        =(ULONG) xSrc;
  818.     MyCaos.d1        =(ULONG) ySrc;
  819.     MyCaos.a1        =(ULONG) destRP;
  820.     MyCaos.d2        =(ULONG) xDest;
  821.     MyCaos.d3        =(ULONG) yDest;
  822.     MyCaos.d4        =(ULONG) xSize;
  823.     MyCaos.d5        =(ULONG) ySize;
  824.     MyCaos.d6        =(ULONG) minterm;
  825.     MyCaos.caos_Un.Offset    =    (-552);
  826.     MyCaos.a6        =(ULONG) GfxBase;    
  827.     PPCCallOS(&MyCaos);
  828. }
  829.  
  830. #define    CloseFont(textFont)    _CloseFont(GRAPHICS_BASE_NAME, textFont)
  831.  
  832. static __inline void
  833. _CloseFont(void *GfxBase, struct TextFont *textFont)
  834. {
  835. struct Caos    MyCaos;
  836.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  837. //    MyCaos.M68kStart    =    NULL;
  838. //    MyCaos.M68kSize        =    0;
  839.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  840. //    MyCaos.PPCStart        =    NULL;
  841. //    MyCaos.PPCSize        =    0;
  842.     MyCaos.a1        =(ULONG) textFont;
  843.     MyCaos.caos_Un.Offset    =    (-78);
  844.     MyCaos.a6        =(ULONG) GfxBase;    
  845.     PPCCallOS(&MyCaos);
  846. }
  847.  
  848. #define    CloseMonitor(monitorSpec)    _CloseMonitor(GRAPHICS_BASE_NAME, monitorSpec)
  849.  
  850. static __inline BOOL
  851. _CloseMonitor(void *GfxBase, struct MonitorSpec *monitorSpec)
  852. {
  853. struct Caos    MyCaos;
  854.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  855. //    MyCaos.M68kStart    =    NULL;
  856. //    MyCaos.M68kSize        =    0;
  857.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  858. //    MyCaos.PPCStart        =    NULL;
  859. //    MyCaos.PPCSize        =    0;
  860.     MyCaos.a0        =(ULONG) monitorSpec;
  861.     MyCaos.caos_Un.Offset    =    (-720);
  862.     MyCaos.a6        =(ULONG) GfxBase;    
  863.     return((BOOL)PPCCallOS(&MyCaos));
  864. }
  865.  
  866. #define    CoerceMode(vp, monitorid, flags)    _CoerceMode(GRAPHICS_BASE_NAME, vp, monitorid, flags)
  867.  
  868. static __inline ULONG
  869. _CoerceMode(void *GfxBase, struct ViewPort *vp, unsigned long monitorid, unsigned long flags)
  870. {
  871. struct Caos    MyCaos;
  872.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  873. //    MyCaos.M68kStart    =    NULL;
  874. //    MyCaos.M68kSize        =    0;
  875.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  876. //    MyCaos.PPCStart        =    NULL;
  877. //    MyCaos.PPCSize        =    0;
  878.     MyCaos.a0        =(ULONG) vp;
  879.     MyCaos.d0        =(ULONG) monitorid;
  880.     MyCaos.d1        =(ULONG) flags;
  881.     MyCaos.caos_Un.Offset    =    (-936);
  882.     MyCaos.a6        =(ULONG) GfxBase;    
  883.     return((ULONG)PPCCallOS(&MyCaos));
  884. }
  885.  
  886. #define    CopySBitMap(layer)    _CopySBitMap(GRAPHICS_BASE_NAME, layer)
  887.  
  888. static __inline void
  889. _CopySBitMap(void *GfxBase, struct Layer *layer)
  890. {
  891. struct Caos    MyCaos;
  892.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  893. //    MyCaos.M68kStart    =    NULL;
  894. //    MyCaos.M68kSize        =    0;
  895.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  896. //    MyCaos.PPCStart        =    NULL;
  897. //    MyCaos.PPCSize        =    0;
  898.     MyCaos.a0        =(ULONG) layer;
  899.     MyCaos.caos_Un.Offset    =    (-450);
  900.     MyCaos.a6        =(ULONG) GfxBase;    
  901.     PPCCallOS(&MyCaos);
  902. }
  903.  
  904. #define    DisownBlitter()    _DisownBlitter(GRAPHICS_BASE_NAME)
  905.  
  906. static __inline void
  907. _DisownBlitter(void *GfxBase)
  908. {
  909. struct Caos    MyCaos;
  910.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  911. //    MyCaos.M68kStart    =    NULL;
  912. //    MyCaos.M68kSize        =    0;
  913.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  914. //    MyCaos.PPCStart        =    NULL;
  915. //    MyCaos.PPCSize        =    0;
  916.     MyCaos.caos_Un.Offset    =    (-462);
  917.     MyCaos.a6        =(ULONG) GfxBase;    
  918.     PPCCallOS(&MyCaos);
  919. }
  920.  
  921. #define    DisposeRegion(region)    _DisposeRegion(GRAPHICS_BASE_NAME, region)
  922.  
  923. static __inline void
  924. _DisposeRegion(void *GfxBase, struct Region *region)
  925. {
  926. struct Caos    MyCaos;
  927.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  928. //    MyCaos.M68kStart    =    NULL;
  929. //    MyCaos.M68kSize        =    0;
  930.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  931. //    MyCaos.PPCStart        =    NULL;
  932. //    MyCaos.PPCSize        =    0;
  933.     MyCaos.a0        =(ULONG) region;
  934.     MyCaos.caos_Un.Offset    =    (-534);
  935.     MyCaos.a6        =(ULONG) GfxBase;    
  936.     PPCCallOS(&MyCaos);
  937. }
  938.  
  939. #define    DoCollision(rp)    _DoCollision(GRAPHICS_BASE_NAME, rp)
  940.  
  941. static __inline void
  942. _DoCollision(void *GfxBase, struct RastPort *rp)
  943. {
  944. struct Caos    MyCaos;
  945.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  946. //    MyCaos.M68kStart    =    NULL;
  947. //    MyCaos.M68kSize        =    0;
  948.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  949. //    MyCaos.PPCStart        =    NULL;
  950. //    MyCaos.PPCSize        =    0;
  951.     MyCaos.a1        =(ULONG) rp;
  952.     MyCaos.caos_Un.Offset    =    (-108);
  953.     MyCaos.a6        =(ULONG) GfxBase;    
  954.     PPCCallOS(&MyCaos);
  955. }
  956.  
  957. #define    Draw(rp, x, y)    _Draw(GRAPHICS_BASE_NAME, rp, x, y)
  958.  
  959. static __inline void
  960. _Draw(void *GfxBase, struct RastPort *rp, long x, long y)
  961. {
  962. struct Caos    MyCaos;
  963.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  964. //    MyCaos.M68kStart    =    NULL;
  965. //    MyCaos.M68kSize        =    0;
  966.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  967. //    MyCaos.PPCStart        =    NULL;
  968. //    MyCaos.PPCSize        =    0;
  969.     MyCaos.a1        =(ULONG) rp;
  970.     MyCaos.d0        =(ULONG) x;
  971.     MyCaos.d1        =(ULONG) y;
  972.     MyCaos.caos_Un.Offset    =    (-246);
  973.     MyCaos.a6        =(ULONG) GfxBase;    
  974.     PPCCallOS(&MyCaos);
  975. }
  976.  
  977. #define    DrawEllipse(rp, xCenter, yCenter, a, b)    _DrawEllipse(GRAPHICS_BASE_NAME, rp, xCenter, yCenter, a, b)
  978.  
  979. static __inline void
  980. _DrawEllipse(void *GfxBase, struct RastPort *rp, long xCenter, long yCenter, long a, long b)
  981. {
  982. struct Caos    MyCaos;
  983.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  984. //    MyCaos.M68kStart    =    NULL;
  985. //    MyCaos.M68kSize        =    0;
  986.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  987. //    MyCaos.PPCStart        =    NULL;
  988. //    MyCaos.PPCSize        =    0;
  989.     MyCaos.a1        =(ULONG) rp;
  990.     MyCaos.d0        =(ULONG) xCenter;
  991.     MyCaos.d1        =(ULONG) yCenter;
  992.     MyCaos.d2        =(ULONG) a;
  993.     MyCaos.d3        =(ULONG) b;
  994.     MyCaos.caos_Un.Offset    =    (-180);
  995.     MyCaos.a6        =(ULONG) GfxBase;    
  996.     PPCCallOS(&MyCaos);
  997. }
  998.  
  999. #define    DrawGList(rp, vp)    _DrawGList(GRAPHICS_BASE_NAME, rp, vp)
  1000.  
  1001. static __inline void
  1002. _DrawGList(void *GfxBase, struct RastPort *rp, struct ViewPort *vp)
  1003. {
  1004. struct Caos    MyCaos;
  1005.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1006. //    MyCaos.M68kStart    =    NULL;
  1007. //    MyCaos.M68kSize        =    0;
  1008.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1009. //    MyCaos.PPCStart        =    NULL;
  1010. //    MyCaos.PPCSize        =    0;
  1011.     MyCaos.a1        =(ULONG) rp;
  1012.     MyCaos.a0        =(ULONG) vp;
  1013.     MyCaos.caos_Un.Offset    =    (-114);
  1014.     MyCaos.a6        =(ULONG) GfxBase;    
  1015.     PPCCallOS(&MyCaos);
  1016. }
  1017.  
  1018. #define    EraseRect(rp, xMin, yMin, xMax, yMax)    _EraseRect(GRAPHICS_BASE_NAME, rp, xMin, yMin, xMax, yMax)
  1019.  
  1020. static __inline void
  1021. _EraseRect(void *GfxBase, struct RastPort *rp, long xMin, long yMin, long xMax, long yMax)
  1022. {
  1023. struct Caos    MyCaos;
  1024.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1025. //    MyCaos.M68kStart    =    NULL;
  1026. //    MyCaos.M68kSize        =    0;
  1027.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1028. //    MyCaos.PPCStart        =    NULL;
  1029. //    MyCaos.PPCSize        =    0;
  1030.     MyCaos.a1        =(ULONG) rp;
  1031.     MyCaos.d0        =(ULONG) xMin;
  1032.     MyCaos.d1        =(ULONG) yMin;
  1033.     MyCaos.d2        =(ULONG) xMax;
  1034.     MyCaos.d3        =(ULONG) yMax;
  1035.     MyCaos.caos_Un.Offset    =    (-810);
  1036.     MyCaos.a6        =(ULONG) GfxBase;    
  1037.     PPCCallOS(&MyCaos);
  1038. }
  1039.  
  1040. #define    ExtendFont(font, fontTags)    _ExtendFont(GRAPHICS_BASE_NAME, font, fontTags)
  1041.  
  1042. static __inline ULONG
  1043. _ExtendFont(void *GfxBase, struct TextFont *font, struct TagItem *fontTags)
  1044. {
  1045. struct Caos    MyCaos;
  1046.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1047. //    MyCaos.M68kStart    =    NULL;
  1048. //    MyCaos.M68kSize        =    0;
  1049.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1050. //    MyCaos.PPCStart        =    NULL;
  1051. //    MyCaos.PPCSize        =    0;
  1052.     MyCaos.a0        =(ULONG) font;
  1053.     MyCaos.a1        =(ULONG) fontTags;
  1054.     MyCaos.caos_Un.Offset    =    (-816);
  1055.     MyCaos.a6        =(ULONG) GfxBase;    
  1056.     return((ULONG)PPCCallOS(&MyCaos));
  1057. }
  1058.  
  1059. #ifndef NO_PPCINLINE_STDARG
  1060. #define ExtendFontTags(a0, tags...) \
  1061.     ({ULONG _tags[] = { tags }; ExtendFont((a0), (struct TagItem *)_tags);})
  1062. #endif /* !NO_PPCINLINE_STDARG */
  1063.  
  1064. #define    FindColor(cm, r, g, b, maxcolor)    _FindColor(GRAPHICS_BASE_NAME, cm, r, g, b, maxcolor)
  1065.  
  1066. static __inline LONG
  1067. _FindColor(void *GfxBase, struct ColorMap *cm, unsigned long r, unsigned long g, unsigned long b, long maxcolor)
  1068. {
  1069. struct Caos    MyCaos;
  1070.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1071. //    MyCaos.M68kStart    =    NULL;
  1072. //    MyCaos.M68kSize        =    0;
  1073.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1074. //    MyCaos.PPCStart        =    NULL;
  1075. //    MyCaos.PPCSize        =    0;
  1076.     MyCaos.a3        =(ULONG) cm;
  1077.     MyCaos.d1        =(ULONG) r;
  1078.     MyCaos.d2        =(ULONG) g;
  1079.     MyCaos.d3        =(ULONG) b;
  1080.     MyCaos.d4        =(ULONG) maxcolor;
  1081.     MyCaos.caos_Un.Offset    =    (-1008);
  1082.     MyCaos.a6        =(ULONG) GfxBase;    
  1083.     return((LONG)PPCCallOS(&MyCaos));
  1084. }
  1085.  
  1086. #define    FindDisplayInfo(displayID)    _FindDisplayInfo(GRAPHICS_BASE_NAME, displayID)
  1087.  
  1088. static __inline DisplayInfoHandle
  1089. _FindDisplayInfo(void *GfxBase, unsigned long displayID)
  1090. {
  1091. struct Caos    MyCaos;
  1092.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1093. //    MyCaos.M68kStart    =    NULL;
  1094. //    MyCaos.M68kSize        =    0;
  1095.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1096. //    MyCaos.PPCStart        =    NULL;
  1097. //    MyCaos.PPCSize        =    0;
  1098.     MyCaos.d0        =(ULONG) displayID;
  1099.     MyCaos.caos_Un.Offset    =    (-726);
  1100.     MyCaos.a6        =(ULONG) GfxBase;    
  1101.     return((DisplayInfoHandle)PPCCallOS(&MyCaos));
  1102. }
  1103.  
  1104. #define    Flood(rp, mode, x, y)    _Flood(GRAPHICS_BASE_NAME, rp, mode, x, y)
  1105.  
  1106. static __inline BOOL
  1107. _Flood(void *GfxBase, struct RastPort *rp, unsigned long mode, long x, long y)
  1108. {
  1109. struct Caos    MyCaos;
  1110.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1111. //    MyCaos.M68kStart    =    NULL;
  1112. //    MyCaos.M68kSize        =    0;
  1113.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1114. //    MyCaos.PPCStart        =    NULL;
  1115. //    MyCaos.PPCSize        =    0;
  1116.     MyCaos.a1        =(ULONG) rp;
  1117.     MyCaos.d2        =(ULONG) mode;
  1118.     MyCaos.d0        =(ULONG) x;
  1119.     MyCaos.d1        =(ULONG) y;
  1120.     MyCaos.caos_Un.Offset    =    (-330);
  1121.     MyCaos.a6        =(ULONG) GfxBase;    
  1122.     return((BOOL)PPCCallOS(&MyCaos));
  1123. }
  1124.  
  1125. #define    FontExtent(font, fontExtent)    _FontExtent(GRAPHICS_BASE_NAME, font, fontExtent)
  1126.  
  1127. static __inline void
  1128. _FontExtent(void *GfxBase, struct TextFont *font, struct TextExtent *fontExtent)
  1129. {
  1130. struct Caos    MyCaos;
  1131.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1132. //    MyCaos.M68kStart    =    NULL;
  1133. //    MyCaos.M68kSize        =    0;
  1134.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1135. //    MyCaos.PPCStart        =    NULL;
  1136. //    MyCaos.PPCSize        =    0;
  1137.     MyCaos.a0        =(ULONG) font;
  1138.     MyCaos.a1        =(ULONG) fontExtent;
  1139.     MyCaos.caos_Un.Offset    =    (-762);
  1140.     MyCaos.a6        =(ULONG) GfxBase;    
  1141.     PPCCallOS(&MyCaos);
  1142. }
  1143.  
  1144. #define    FreeBitMap(bm)    _FreeBitMap(GRAPHICS_BASE_NAME, bm)
  1145.  
  1146. static __inline void
  1147. _FreeBitMap(void *GfxBase, struct BitMap *bm)
  1148. {
  1149. struct Caos    MyCaos;
  1150.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1151. //    MyCaos.M68kStart    =    NULL;
  1152. //    MyCaos.M68kSize        =    0;
  1153.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1154. //    MyCaos.PPCStart        =    NULL;
  1155. //    MyCaos.PPCSize        =    0;
  1156.     MyCaos.a0        =(ULONG) bm;
  1157.     MyCaos.caos_Un.Offset    =    (-924);
  1158.     MyCaos.a6        =(ULONG) GfxBase;    
  1159.     PPCCallOS(&MyCaos);
  1160. }
  1161.  
  1162. #define    FreeColorMap(colorMap)    _FreeColorMap(GRAPHICS_BASE_NAME, colorMap)
  1163.  
  1164. static __inline void
  1165. _FreeColorMap(void *GfxBase, struct ColorMap *colorMap)
  1166. {
  1167. struct Caos    MyCaos;
  1168.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1169. //    MyCaos.M68kStart    =    NULL;
  1170. //    MyCaos.M68kSize        =    0;
  1171.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1172. //    MyCaos.PPCStart        =    NULL;
  1173. //    MyCaos.PPCSize        =    0;
  1174.     MyCaos.a0        =(ULONG) colorMap;
  1175.     MyCaos.caos_Un.Offset    =    (-576);
  1176.     MyCaos.a6        =(ULONG) GfxBase;    
  1177.     PPCCallOS(&MyCaos);
  1178. }
  1179.  
  1180. #define    FreeCopList(copList)    _FreeCopList(GRAPHICS_BASE_NAME, copList)
  1181.  
  1182. static __inline void
  1183. _FreeCopList(void *GfxBase, struct CopList *copList)
  1184. {
  1185. struct Caos    MyCaos;
  1186.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1187. //    MyCaos.M68kStart    =    NULL;
  1188. //    MyCaos.M68kSize        =    0;
  1189.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1190. //    MyCaos.PPCStart        =    NULL;
  1191. //    MyCaos.PPCSize        =    0;
  1192.     MyCaos.a0        =(ULONG) copList;
  1193.     MyCaos.caos_Un.Offset    =    (-546);
  1194.     MyCaos.a6        =(ULONG) GfxBase;    
  1195.     PPCCallOS(&MyCaos);
  1196. }
  1197.  
  1198. #define    FreeCprList(cprList)    _FreeCprList(GRAPHICS_BASE_NAME, cprList)
  1199.  
  1200. static __inline void
  1201. _FreeCprList(void *GfxBase, struct cprlist *cprList)
  1202. {
  1203. struct Caos    MyCaos;
  1204.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1205. //    MyCaos.M68kStart    =    NULL;
  1206. //    MyCaos.M68kSize        =    0;
  1207.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1208. //    MyCaos.PPCStart        =    NULL;
  1209. //    MyCaos.PPCSize        =    0;
  1210.     MyCaos.a0        =(ULONG) cprList;
  1211.     MyCaos.caos_Un.Offset    =    (-564);
  1212.     MyCaos.a6        =(ULONG) GfxBase;    
  1213.     PPCCallOS(&MyCaos);
  1214. }
  1215.  
  1216. #define    FreeDBufInfo(dbi)    _FreeDBufInfo(GRAPHICS_BASE_NAME, dbi)
  1217.  
  1218. static __inline void
  1219. _FreeDBufInfo(void *GfxBase, struct DBufInfo *dbi)
  1220. {
  1221. struct Caos    MyCaos;
  1222.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1223. //    MyCaos.M68kStart    =    NULL;
  1224. //    MyCaos.M68kSize        =    0;
  1225.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1226. //    MyCaos.PPCStart        =    NULL;
  1227. //    MyCaos.PPCSize        =    0;
  1228.     MyCaos.a1        =(ULONG) dbi;
  1229.     MyCaos.caos_Un.Offset    =    (-972);
  1230.     MyCaos.a6        =(ULONG) GfxBase;    
  1231.     PPCCallOS(&MyCaos);
  1232. }
  1233.  
  1234. #define    FreeGBuffers(anOb, rp, flag)    _FreeGBuffers(GRAPHICS_BASE_NAME, anOb, rp, flag)
  1235.  
  1236. static __inline void
  1237. _FreeGBuffers(void *GfxBase, struct AnimOb *anOb, struct RastPort *rp, long flag)
  1238. {
  1239. struct Caos    MyCaos;
  1240.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1241. //    MyCaos.M68kStart    =    NULL;
  1242. //    MyCaos.M68kSize        =    0;
  1243.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1244. //    MyCaos.PPCStart        =    NULL;
  1245. //    MyCaos.PPCSize        =    0;
  1246.     MyCaos.a0        =(ULONG) anOb;
  1247.     MyCaos.a1        =(ULONG) rp;
  1248.     MyCaos.d0        =(ULONG) flag;
  1249.     MyCaos.caos_Un.Offset    =    (-600);
  1250.     MyCaos.a6        =(ULONG) GfxBase;    
  1251.     PPCCallOS(&MyCaos);
  1252. }
  1253.  
  1254. #define    FreeRaster(p, width, height)    _FreeRaster(GRAPHICS_BASE_NAME, p, width, height)
  1255.  
  1256. static __inline void
  1257. _FreeRaster(void *GfxBase, PLANEPTR p, unsigned long width, unsigned long height)
  1258. {
  1259. struct Caos    MyCaos;
  1260.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1261. //    MyCaos.M68kStart    =    NULL;
  1262. //    MyCaos.M68kSize        =    0;
  1263.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1264. //    MyCaos.PPCStart        =    NULL;
  1265. //    MyCaos.PPCSize        =    0;
  1266.     MyCaos.a0        =(ULONG) p;
  1267.     MyCaos.d0        =(ULONG) width;
  1268.     MyCaos.d1        =(ULONG) height;
  1269.     MyCaos.caos_Un.Offset    =    (-498);
  1270.     MyCaos.a6        =(ULONG) GfxBase;    
  1271.     PPCCallOS(&MyCaos);
  1272. }
  1273.  
  1274. #define    FreeSprite(num)    _FreeSprite(GRAPHICS_BASE_NAME, num)
  1275.  
  1276. static __inline void
  1277. _FreeSprite(void *GfxBase, long num)
  1278. {
  1279. struct Caos    MyCaos;
  1280.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1281. //    MyCaos.M68kStart    =    NULL;
  1282. //    MyCaos.M68kSize        =    0;
  1283.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1284. //    MyCaos.PPCStart        =    NULL;
  1285. //    MyCaos.PPCSize        =    0;
  1286.     MyCaos.d0        =(ULONG) num;
  1287.     MyCaos.caos_Un.Offset    =    (-414);
  1288.     MyCaos.a6        =(ULONG) GfxBase;    
  1289.     PPCCallOS(&MyCaos);
  1290. }
  1291.  
  1292. #define    FreeSpriteData(sp)    _FreeSpriteData(GRAPHICS_BASE_NAME, sp)
  1293.  
  1294. static __inline void
  1295. _FreeSpriteData(void *GfxBase, struct ExtSprite *sp)
  1296. {
  1297. struct Caos    MyCaos;
  1298.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1299. //    MyCaos.M68kStart    =    NULL;
  1300. //    MyCaos.M68kSize        =    0;
  1301.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1302. //    MyCaos.PPCStart        =    NULL;
  1303. //    MyCaos.PPCSize        =    0;
  1304.     MyCaos.a2        =(ULONG) sp;
  1305.     MyCaos.caos_Un.Offset    =    (-1032);
  1306.     MyCaos.a6        =(ULONG) GfxBase;    
  1307.     PPCCallOS(&MyCaos);
  1308. }
  1309.  
  1310. #define    FreeVPortCopLists(vp)    _FreeVPortCopLists(GRAPHICS_BASE_NAME, vp)
  1311.  
  1312. static __inline void
  1313. _FreeVPortCopLists(void *GfxBase, struct ViewPort *vp)
  1314. {
  1315. struct Caos    MyCaos;
  1316.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1317. //    MyCaos.M68kStart    =    NULL;
  1318. //    MyCaos.M68kSize        =    0;
  1319.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1320. //    MyCaos.PPCStart        =    NULL;
  1321. //    MyCaos.PPCSize        =    0;
  1322.     MyCaos.a0        =(ULONG) vp;
  1323.     MyCaos.caos_Un.Offset    =    (-540);
  1324.     MyCaos.a6        =(ULONG) GfxBase;    
  1325.     PPCCallOS(&MyCaos);
  1326. }
  1327.  
  1328. #define    GetAPen(rp)    _GetAPen(GRAPHICS_BASE_NAME, rp)
  1329.  
  1330. static __inline ULONG
  1331. _GetAPen(void *GfxBase, struct RastPort *rp)
  1332. {
  1333. struct Caos    MyCaos;
  1334.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1335. //    MyCaos.M68kStart    =    NULL;
  1336. //    MyCaos.M68kSize        =    0;
  1337.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1338. //    MyCaos.PPCStart        =    NULL;
  1339. //    MyCaos.PPCSize        =    0;
  1340.     MyCaos.a0        =(ULONG) rp;
  1341.     MyCaos.caos_Un.Offset    =    (-858);
  1342.     MyCaos.a6        =(ULONG) GfxBase;    
  1343.     return((ULONG)PPCCallOS(&MyCaos));
  1344. }
  1345.  
  1346. #define    GetBPen(rp)    _GetBPen(GRAPHICS_BASE_NAME, rp)
  1347.  
  1348. static __inline ULONG
  1349. _GetBPen(void *GfxBase, struct RastPort *rp)
  1350. {
  1351. struct Caos    MyCaos;
  1352.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1353. //    MyCaos.M68kStart    =    NULL;
  1354. //    MyCaos.M68kSize        =    0;
  1355.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1356. //    MyCaos.PPCStart        =    NULL;
  1357. //    MyCaos.PPCSize        =    0;
  1358.     MyCaos.a0        =(ULONG) rp;
  1359.     MyCaos.caos_Un.Offset    =    (-864);
  1360.     MyCaos.a6        =(ULONG) GfxBase;    
  1361.     return((ULONG)PPCCallOS(&MyCaos));
  1362. }
  1363.  
  1364. #define    GetBitMapAttr(bm, attrnum)    _GetBitMapAttr(GRAPHICS_BASE_NAME, bm, attrnum)
  1365.  
  1366. static __inline ULONG
  1367. _GetBitMapAttr(void *GfxBase, struct BitMap *bm, unsigned long attrnum)
  1368. {
  1369. struct Caos    MyCaos;
  1370.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1371. //    MyCaos.M68kStart    =    NULL;
  1372. //    MyCaos.M68kSize        =    0;
  1373.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1374. //    MyCaos.PPCStart        =    NULL;
  1375. //    MyCaos.PPCSize        =    0;
  1376.     MyCaos.a0        =(ULONG) bm;
  1377.     MyCaos.d1        =(ULONG) attrnum;
  1378.     MyCaos.caos_Un.Offset    =    (-960);
  1379.     MyCaos.a6        =(ULONG) GfxBase;    
  1380.     return((ULONG)PPCCallOS(&MyCaos));
  1381. }
  1382.  
  1383. #define    GetColorMap(entries)    _GetColorMap(GRAPHICS_BASE_NAME, entries)
  1384.  
  1385. static __inline struct ColorMap *
  1386. _GetColorMap(void *GfxBase, long entries)
  1387. {
  1388. struct Caos    MyCaos;
  1389.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1390. //    MyCaos.M68kStart    =    NULL;
  1391. //    MyCaos.M68kSize        =    0;
  1392.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1393. //    MyCaos.PPCStart        =    NULL;
  1394. //    MyCaos.PPCSize        =    0;
  1395.     MyCaos.d0        =(ULONG) entries;
  1396.     MyCaos.caos_Un.Offset    =    (-570);
  1397.     MyCaos.a6        =(ULONG) GfxBase;    
  1398.     return((struct ColorMap *)PPCCallOS(&MyCaos));
  1399. }
  1400.  
  1401. #define    GetDisplayInfoData(handle, buf, size, tagID, displayID)    _GetDisplayInfoData(GRAPHICS_BASE_NAME, handle, buf, size, tagID, displayID)
  1402.  
  1403. static __inline ULONG
  1404. _GetDisplayInfoData(void *GfxBase, DisplayInfoHandle handle, UBYTE *buf, unsigned long size, unsigned long tagID, unsigned long displayID)
  1405. {
  1406. struct Caos    MyCaos;
  1407.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1408. //    MyCaos.M68kStart    =    NULL;
  1409. //    MyCaos.M68kSize        =    0;
  1410.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1411. //    MyCaos.PPCStart        =    NULL;
  1412. //    MyCaos.PPCSize        =    0;
  1413.     MyCaos.a0        =(ULONG) handle;
  1414.     MyCaos.a1        =(ULONG) buf;
  1415.     MyCaos.d0        =(ULONG) size;
  1416.     MyCaos.d1        =(ULONG) tagID;
  1417.     MyCaos.d2        =(ULONG) displayID;
  1418.     MyCaos.caos_Un.Offset    =    (-756);
  1419.     MyCaos.a6        =(ULONG) GfxBase;    
  1420.     return((ULONG)PPCCallOS(&MyCaos));
  1421. }
  1422.  
  1423. #define    GetDrMd(rp)    _GetDrMd(GRAPHICS_BASE_NAME, rp)
  1424.  
  1425. static __inline ULONG
  1426. _GetDrMd(void *GfxBase, struct RastPort *rp)
  1427. {
  1428. struct Caos    MyCaos;
  1429.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1430. //    MyCaos.M68kStart    =    NULL;
  1431. //    MyCaos.M68kSize        =    0;
  1432.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1433. //    MyCaos.PPCStart        =    NULL;
  1434. //    MyCaos.PPCSize        =    0;
  1435.     MyCaos.a0        =(ULONG) rp;
  1436.     MyCaos.caos_Un.Offset    =    (-870);
  1437.     MyCaos.a6        =(ULONG) GfxBase;    
  1438.     return((ULONG)PPCCallOS(&MyCaos));
  1439. }
  1440.  
  1441. #define    GetExtSpriteA(ss, tags)    _GetExtSpriteA(GRAPHICS_BASE_NAME, ss, tags)
  1442.  
  1443. static __inline LONG
  1444. _GetExtSpriteA(void *GfxBase, struct ExtSprite *ss, struct TagItem *tags)
  1445. {
  1446. struct Caos    MyCaos;
  1447.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1448. //    MyCaos.M68kStart    =    NULL;
  1449. //    MyCaos.M68kSize        =    0;
  1450.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1451. //    MyCaos.PPCStart        =    NULL;
  1452. //    MyCaos.PPCSize        =    0;
  1453.     MyCaos.a2        =(ULONG) ss;
  1454.     MyCaos.a1        =(ULONG) tags;
  1455.     MyCaos.caos_Un.Offset    =    (-930);
  1456.     MyCaos.a6        =(ULONG) GfxBase;    
  1457.     return((LONG)PPCCallOS(&MyCaos));
  1458. }
  1459.  
  1460. #ifndef NO_PPCINLINE_STDARG
  1461. #define GetExtSprite(a0, tags...) \
  1462.     ({ULONG _tags[] = { tags }; GetExtSpriteA((a0), (struct TagItem *)_tags);})
  1463. #endif /* !NO_PPCINLINE_STDARG */
  1464.  
  1465. #define    GetGBuffers(anOb, rp, flag)    _GetGBuffers(GRAPHICS_BASE_NAME, anOb, rp, flag)
  1466.  
  1467. static __inline BOOL
  1468. _GetGBuffers(void *GfxBase, struct AnimOb *anOb, struct RastPort *rp, long flag)
  1469. {
  1470. struct Caos    MyCaos;
  1471.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1472. //    MyCaos.M68kStart    =    NULL;
  1473. //    MyCaos.M68kSize        =    0;
  1474.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1475. //    MyCaos.PPCStart        =    NULL;
  1476. //    MyCaos.PPCSize        =    0;
  1477.     MyCaos.a0        =(ULONG) anOb;
  1478.     MyCaos.a1        =(ULONG) rp;
  1479.     MyCaos.d0        =(ULONG) flag;
  1480.     MyCaos.caos_Un.Offset    =    (-168);
  1481.     MyCaos.a6        =(ULONG) GfxBase;    
  1482.     return((BOOL)PPCCallOS(&MyCaos));
  1483. }
  1484.  
  1485. #define    GetOutlinePen(rp)    _GetOutlinePen(GRAPHICS_BASE_NAME, rp)
  1486.  
  1487. static __inline ULONG
  1488. _GetOutlinePen(void *GfxBase, struct RastPort *rp)
  1489. {
  1490. struct Caos    MyCaos;
  1491.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1492. //    MyCaos.M68kStart    =    NULL;
  1493. //    MyCaos.M68kSize        =    0;
  1494.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1495. //    MyCaos.PPCStart        =    NULL;
  1496. //    MyCaos.PPCSize        =    0;
  1497.     MyCaos.a0        =(ULONG) rp;
  1498.     MyCaos.caos_Un.Offset    =    (-876);
  1499.     MyCaos.a6        =(ULONG) GfxBase;    
  1500.     return((ULONG)PPCCallOS(&MyCaos));
  1501. }
  1502.  
  1503. #define    GetRGB32(cm, firstcolor, ncolors, table)    _GetRGB32(GRAPHICS_BASE_NAME, cm, firstcolor, ncolors, table)
  1504.  
  1505. static __inline void
  1506. _GetRGB32(void *GfxBase, struct ColorMap *cm, unsigned long firstcolor, unsigned long ncolors, ULONG *table)
  1507. {
  1508. struct Caos    MyCaos;
  1509.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1510. //    MyCaos.M68kStart    =    NULL;
  1511. //    MyCaos.M68kSize        =    0;
  1512.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1513. //    MyCaos.PPCStart        =    NULL;
  1514. //    MyCaos.PPCSize        =    0;
  1515.     MyCaos.a0        =(ULONG) cm;
  1516.     MyCaos.d0        =(ULONG) firstcolor;
  1517.     MyCaos.d1        =(ULONG) ncolors;
  1518.     MyCaos.a1        =(ULONG) table;
  1519.     MyCaos.caos_Un.Offset    =    (-900);
  1520.     MyCaos.a6        =(ULONG) GfxBase;    
  1521.     PPCCallOS(&MyCaos);
  1522. }
  1523.  
  1524. #define    GetRGB4(colorMap, entry)    _GetRGB4(GRAPHICS_BASE_NAME, colorMap, entry)
  1525.  
  1526. static __inline ULONG
  1527. _GetRGB4(void *GfxBase, struct ColorMap *colorMap, long entry)
  1528. {
  1529. struct Caos    MyCaos;
  1530.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1531. //    MyCaos.M68kStart    =    NULL;
  1532. //    MyCaos.M68kSize        =    0;
  1533.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1534. //    MyCaos.PPCStart        =    NULL;
  1535. //    MyCaos.PPCSize        =    0;
  1536.     MyCaos.a0        =(ULONG) colorMap;
  1537.     MyCaos.d0        =(ULONG) entry;
  1538.     MyCaos.caos_Un.Offset    =    (-582);
  1539.     MyCaos.a6        =(ULONG) GfxBase;    
  1540.     return((ULONG)PPCCallOS(&MyCaos));
  1541. }
  1542.  
  1543. #define    GetRPAttrsA(rp, tags)    _GetRPAttrsA(GRAPHICS_BASE_NAME, rp, tags)
  1544.  
  1545. static __inline void
  1546. _GetRPAttrsA(void *GfxBase, struct RastPort *rp, struct TagItem *tags)
  1547. {
  1548. struct Caos    MyCaos;
  1549.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1550. //    MyCaos.M68kStart    =    NULL;
  1551. //    MyCaos.M68kSize        =    0;
  1552.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1553. //    MyCaos.PPCStart        =    NULL;
  1554. //    MyCaos.PPCSize        =    0;
  1555.     MyCaos.a0        =(ULONG) rp;
  1556.     MyCaos.a1        =(ULONG) tags;
  1557.     MyCaos.caos_Un.Offset    =    (-1044);
  1558.     MyCaos.a6        =(ULONG) GfxBase;    
  1559.     PPCCallOS(&MyCaos);
  1560. }
  1561.  
  1562. #ifndef NO_PPCINLINE_STDARG
  1563. #define GetRPAttrs(a0, tags...) \
  1564.     ({ULONG _tags[] = { tags }; GetRPAttrsA((a0), (struct TagItem *)_tags);})
  1565. #endif /* !NO_PPCINLINE_STDARG */
  1566.  
  1567. #define    GetSprite(sprite, num)    _GetSprite(GRAPHICS_BASE_NAME, sprite, num)
  1568.  
  1569. static __inline WORD
  1570. _GetSprite(void *GfxBase, struct SimpleSprite *sprite, long num)
  1571. {
  1572. struct Caos    MyCaos;
  1573.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1574. //    MyCaos.M68kStart    =    NULL;
  1575. //    MyCaos.M68kSize        =    0;
  1576.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1577. //    MyCaos.PPCStart        =    NULL;
  1578. //    MyCaos.PPCSize        =    0;
  1579.     MyCaos.a0        =(ULONG) sprite;
  1580.     MyCaos.d0        =(ULONG) num;
  1581.     MyCaos.caos_Un.Offset    =    (-408);
  1582.     MyCaos.a6        =(ULONG) GfxBase;    
  1583.     return((WORD)PPCCallOS(&MyCaos));
  1584. }
  1585.  
  1586. #define    GetVPModeID(vp)    _GetVPModeID(GRAPHICS_BASE_NAME, vp)
  1587.  
  1588. static __inline LONG
  1589. _GetVPModeID(void *GfxBase, struct ViewPort *vp)
  1590. {
  1591. struct Caos    MyCaos;
  1592.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1593. //    MyCaos.M68kStart    =    NULL;
  1594. //    MyCaos.M68kSize        =    0;
  1595.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1596. //    MyCaos.PPCStart        =    NULL;
  1597. //    MyCaos.PPCSize        =    0;
  1598.     MyCaos.a0        =(ULONG) vp;
  1599.     MyCaos.caos_Un.Offset    =    (-792);
  1600.     MyCaos.a6        =(ULONG) GfxBase;    
  1601.     return((LONG)PPCCallOS(&MyCaos));
  1602. }
  1603.  
  1604. #define    GfxAssociate(associateNode, gfxNodePtr)    _GfxAssociate(GRAPHICS_BASE_NAME, associateNode, gfxNodePtr)
  1605.  
  1606. static __inline void
  1607. _GfxAssociate(void *GfxBase, APTR associateNode, APTR gfxNodePtr)
  1608. {
  1609. struct Caos    MyCaos;
  1610.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1611. //    MyCaos.M68kStart    =    NULL;
  1612. //    MyCaos.M68kSize        =    0;
  1613.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1614. //    MyCaos.PPCStart        =    NULL;
  1615. //    MyCaos.PPCSize        =    0;
  1616.     MyCaos.a0        =(ULONG) associateNode;
  1617.     MyCaos.a1        =(ULONG) gfxNodePtr;
  1618.     MyCaos.caos_Un.Offset    =    (-672);
  1619.     MyCaos.a6        =(ULONG) GfxBase;    
  1620.     PPCCallOS(&MyCaos);
  1621. }
  1622.  
  1623. #define    GfxFree(gfxNodePtr)    _GfxFree(GRAPHICS_BASE_NAME, gfxNodePtr)
  1624.  
  1625. static __inline void
  1626. _GfxFree(void *GfxBase, APTR gfxNodePtr)
  1627. {
  1628. struct Caos    MyCaos;
  1629.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1630. //    MyCaos.M68kStart    =    NULL;
  1631. //    MyCaos.M68kSize        =    0;
  1632.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1633. //    MyCaos.PPCStart        =    NULL;
  1634. //    MyCaos.PPCSize        =    0;
  1635.     MyCaos.a0        =(ULONG) gfxNodePtr;
  1636.     MyCaos.caos_Un.Offset    =    (-666);
  1637.     MyCaos.a6        =(ULONG) GfxBase;    
  1638.     PPCCallOS(&MyCaos);
  1639. }
  1640.  
  1641. #define    GfxLookUp(associateNode)    _GfxLookUp(GRAPHICS_BASE_NAME, associateNode)
  1642.  
  1643. static __inline APTR
  1644. _GfxLookUp(void *GfxBase, APTR associateNode)
  1645. {
  1646. struct Caos    MyCaos;
  1647.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1648. //    MyCaos.M68kStart    =    NULL;
  1649. //    MyCaos.M68kSize        =    0;
  1650.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1651. //    MyCaos.PPCStart        =    NULL;
  1652. //    MyCaos.PPCSize        =    0;
  1653.     MyCaos.a0        =(ULONG) associateNode;
  1654.     MyCaos.caos_Un.Offset    =    (-702);
  1655.     MyCaos.a6        =(ULONG) GfxBase;    
  1656.     return((APTR)PPCCallOS(&MyCaos));
  1657. }
  1658.  
  1659. #define    GfxNew(gfxNodeType)    _GfxNew(GRAPHICS_BASE_NAME, gfxNodeType)
  1660.  
  1661. static __inline APTR
  1662. _GfxNew(void *GfxBase, unsigned long gfxNodeType)
  1663. {
  1664. struct Caos    MyCaos;
  1665.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1666. //    MyCaos.M68kStart    =    NULL;
  1667. //    MyCaos.M68kSize        =    0;
  1668.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1669. //    MyCaos.PPCStart        =    NULL;
  1670. //    MyCaos.PPCSize        =    0;
  1671.     MyCaos.d0        =(ULONG) gfxNodeType;
  1672.     MyCaos.caos_Un.Offset    =    (-660);
  1673.     MyCaos.a6        =(ULONG) GfxBase;    
  1674.     return((APTR)PPCCallOS(&MyCaos));
  1675. }
  1676.  
  1677. #define    InitArea(areaInfo, vectorBuffer, maxVectors)    _InitArea(GRAPHICS_BASE_NAME, areaInfo, vectorBuffer, maxVectors)
  1678.  
  1679. static __inline void
  1680. _InitArea(void *GfxBase, struct AreaInfo *areaInfo, APTR vectorBuffer, long maxVectors)
  1681. {
  1682. struct Caos    MyCaos;
  1683.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1684. //    MyCaos.M68kStart    =    NULL;
  1685. //    MyCaos.M68kSize        =    0;
  1686.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1687. //    MyCaos.PPCStart        =    NULL;
  1688. //    MyCaos.PPCSize        =    0;
  1689.     MyCaos.a0        =(ULONG) areaInfo;
  1690.     MyCaos.a1        =(ULONG) vectorBuffer;
  1691.     MyCaos.d0        =(ULONG) maxVectors;
  1692.     MyCaos.caos_Un.Offset    =    (-282);
  1693.     MyCaos.a6        =(ULONG) GfxBase;    
  1694.     PPCCallOS(&MyCaos);
  1695. }
  1696.  
  1697. #define    InitBitMap(bitMap, depth, width, height)    _InitBitMap(GRAPHICS_BASE_NAME, bitMap, depth, width, height)
  1698.  
  1699. static __inline void
  1700. _InitBitMap(void *GfxBase, struct BitMap *bitMap, long depth, long width, long height)
  1701. {
  1702. struct Caos    MyCaos;
  1703.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1704. //    MyCaos.M68kStart    =    NULL;
  1705. //    MyCaos.M68kSize        =    0;
  1706.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1707. //    MyCaos.PPCStart        =    NULL;
  1708. //    MyCaos.PPCSize        =    0;
  1709.     MyCaos.a0        =(ULONG) bitMap;
  1710.     MyCaos.d0        =(ULONG) depth;
  1711.     MyCaos.d1        =(ULONG) width;
  1712.     MyCaos.d2        =(ULONG) height;
  1713.     MyCaos.caos_Un.Offset    =    (-390);
  1714.     MyCaos.a6        =(ULONG) GfxBase;    
  1715.     PPCCallOS(&MyCaos);
  1716. }
  1717.  
  1718. #define    InitGMasks(anOb)    _InitGMasks(GRAPHICS_BASE_NAME, anOb)
  1719.  
  1720. static __inline void
  1721. _InitGMasks(void *GfxBase, struct AnimOb *anOb)
  1722. {
  1723. struct Caos    MyCaos;
  1724.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1725. //    MyCaos.M68kStart    =    NULL;
  1726. //    MyCaos.M68kSize        =    0;
  1727.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1728. //    MyCaos.PPCStart        =    NULL;
  1729. //    MyCaos.PPCSize        =    0;
  1730.     MyCaos.a0        =(ULONG) anOb;
  1731.     MyCaos.caos_Un.Offset    =    (-174);
  1732.     MyCaos.a6        =(ULONG) GfxBase;    
  1733.     PPCCallOS(&MyCaos);
  1734. }
  1735.  
  1736. #define    InitGels(head, tail, gelsInfo)    _InitGels(GRAPHICS_BASE_NAME, head, tail, gelsInfo)
  1737.  
  1738. static __inline void
  1739. _InitGels(void *GfxBase, struct VSprite *head, struct VSprite *tail, struct GelsInfo *gelsInfo)
  1740. {
  1741. struct Caos    MyCaos;
  1742.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1743. //    MyCaos.M68kStart    =    NULL;
  1744. //    MyCaos.M68kSize        =    0;
  1745.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1746. //    MyCaos.PPCStart        =    NULL;
  1747. //    MyCaos.PPCSize        =    0;
  1748.     MyCaos.a0        =(ULONG) head;
  1749.     MyCaos.a1        =(ULONG) tail;
  1750.     MyCaos.a2        =(ULONG) gelsInfo;
  1751.     MyCaos.caos_Un.Offset    =    (-120);
  1752.     MyCaos.a6        =(ULONG) GfxBase;    
  1753.     PPCCallOS(&MyCaos);
  1754. }
  1755.  
  1756. #define    InitMasks(vSprite)    _InitMasks(GRAPHICS_BASE_NAME, vSprite)
  1757.  
  1758. static __inline void
  1759. _InitMasks(void *GfxBase, struct VSprite *vSprite)
  1760. {
  1761. struct Caos    MyCaos;
  1762.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1763. //    MyCaos.M68kStart    =    NULL;
  1764. //    MyCaos.M68kSize        =    0;
  1765.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1766. //    MyCaos.PPCStart        =    NULL;
  1767. //    MyCaos.PPCSize        =    0;
  1768.     MyCaos.a0        =(ULONG) vSprite;
  1769.     MyCaos.caos_Un.Offset    =    (-126);
  1770.     MyCaos.a6        =(ULONG) GfxBase;    
  1771.     PPCCallOS(&MyCaos);
  1772. }
  1773.  
  1774. #define    InitRastPort(rp)    _InitRastPort(GRAPHICS_BASE_NAME, rp)
  1775.  
  1776. static __inline void
  1777. _InitRastPort(void *GfxBase, struct RastPort *rp)
  1778. {
  1779. struct Caos    MyCaos;
  1780.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1781. //    MyCaos.M68kStart    =    NULL;
  1782. //    MyCaos.M68kSize        =    0;
  1783.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1784. //    MyCaos.PPCStart        =    NULL;
  1785. //    MyCaos.PPCSize        =    0;
  1786.     MyCaos.a1        =(ULONG) rp;
  1787.     MyCaos.caos_Un.Offset    =    (-198);
  1788.     MyCaos.a6        =(ULONG) GfxBase;    
  1789.     PPCCallOS(&MyCaos);
  1790. }
  1791.  
  1792. #define    InitTmpRas(tmpRas, buffer, size)    _InitTmpRas(GRAPHICS_BASE_NAME, tmpRas, buffer, size)
  1793.  
  1794. static __inline struct TmpRas *
  1795. _InitTmpRas(void *GfxBase, struct TmpRas *tmpRas, PLANEPTR buffer, long size)
  1796. {
  1797. struct Caos    MyCaos;
  1798.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1799. //    MyCaos.M68kStart    =    NULL;
  1800. //    MyCaos.M68kSize        =    0;
  1801.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1802. //    MyCaos.PPCStart        =    NULL;
  1803. //    MyCaos.PPCSize        =    0;
  1804.     MyCaos.a0        =(ULONG) tmpRas;
  1805.     MyCaos.a1        =(ULONG) buffer;
  1806.     MyCaos.d0        =(ULONG) size;
  1807.     MyCaos.caos_Un.Offset    =    (-468);
  1808.     MyCaos.a6        =(ULONG) GfxBase;    
  1809.     return((struct TmpRas *)PPCCallOS(&MyCaos));
  1810. }
  1811.  
  1812. #define    InitVPort(vp)    _InitVPort(GRAPHICS_BASE_NAME, vp)
  1813.  
  1814. static __inline void
  1815. _InitVPort(void *GfxBase, struct ViewPort *vp)
  1816. {
  1817. struct Caos    MyCaos;
  1818.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1819. //    MyCaos.M68kStart    =    NULL;
  1820. //    MyCaos.M68kSize        =    0;
  1821.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1822. //    MyCaos.PPCStart        =    NULL;
  1823. //    MyCaos.PPCSize        =    0;
  1824.     MyCaos.a0        =(ULONG) vp;
  1825.     MyCaos.caos_Un.Offset    =    (-204);
  1826.     MyCaos.a6        =(ULONG) GfxBase;    
  1827.     PPCCallOS(&MyCaos);
  1828. }
  1829.  
  1830. #define    InitView(view)    _InitView(GRAPHICS_BASE_NAME, view)
  1831.  
  1832. static __inline void
  1833. _InitView(void *GfxBase, struct View *view)
  1834. {
  1835. struct Caos    MyCaos;
  1836.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1837. //    MyCaos.M68kStart    =    NULL;
  1838. //    MyCaos.M68kSize        =    0;
  1839.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1840. //    MyCaos.PPCStart        =    NULL;
  1841. //    MyCaos.PPCSize        =    0;
  1842.     MyCaos.a1        =(ULONG) view;
  1843.     MyCaos.caos_Un.Offset    =    (-360);
  1844.     MyCaos.a6        =(ULONG) GfxBase;    
  1845.     PPCCallOS(&MyCaos);
  1846. }
  1847.  
  1848. #define    LoadRGB32(vp, table)    _LoadRGB32(GRAPHICS_BASE_NAME, vp, table)
  1849.  
  1850. static __inline void
  1851. _LoadRGB32(void *GfxBase, struct ViewPort *vp, ULONG *table)
  1852. {
  1853. struct Caos    MyCaos;
  1854.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1855. //    MyCaos.M68kStart    =    NULL;
  1856. //    MyCaos.M68kSize        =    0;
  1857.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1858. //    MyCaos.PPCStart        =    NULL;
  1859. //    MyCaos.PPCSize        =    0;
  1860.     MyCaos.a0        =(ULONG) vp;
  1861.     MyCaos.a1        =(ULONG) table;
  1862.     MyCaos.caos_Un.Offset    =    (-882);
  1863.     MyCaos.a6        =(ULONG) GfxBase;    
  1864.     PPCCallOS(&MyCaos);
  1865. }
  1866.  
  1867. #define    LoadRGB4(vp, colors, count)    _LoadRGB4(GRAPHICS_BASE_NAME, vp, colors, count)
  1868.  
  1869. static __inline void
  1870. _LoadRGB4(void *GfxBase, struct ViewPort *vp, UWORD *colors, long count)
  1871. {
  1872. struct Caos    MyCaos;
  1873.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1874. //    MyCaos.M68kStart    =    NULL;
  1875. //    MyCaos.M68kSize        =    0;
  1876.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1877. //    MyCaos.PPCStart        =    NULL;
  1878. //    MyCaos.PPCSize        =    0;
  1879.     MyCaos.a0        =(ULONG) vp;
  1880.     MyCaos.a1        =(ULONG) colors;
  1881.     MyCaos.d0        =(ULONG) count;
  1882.     MyCaos.caos_Un.Offset    =    (-192);
  1883.     MyCaos.a6        =(ULONG) GfxBase;    
  1884.     PPCCallOS(&MyCaos);
  1885. }
  1886.  
  1887. #define    LoadView(view)    _LoadView(GRAPHICS_BASE_NAME, view)
  1888.  
  1889. static __inline void
  1890. _LoadView(void *GfxBase, struct View *view)
  1891. {
  1892. struct Caos    MyCaos;
  1893.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1894. //    MyCaos.M68kStart    =    NULL;
  1895. //    MyCaos.M68kSize        =    0;
  1896.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1897. //    MyCaos.PPCStart        =    NULL;
  1898. //    MyCaos.PPCSize        =    0;
  1899.     MyCaos.a1        =(ULONG) view;
  1900.     MyCaos.caos_Un.Offset    =    (-222);
  1901.     MyCaos.a6        =(ULONG) GfxBase;    
  1902.     PPCCallOS(&MyCaos);
  1903. }
  1904.  
  1905. #define    LockLayerRom(layer)    _LockLayerRom(GRAPHICS_BASE_NAME, layer)
  1906.  
  1907. static __inline void
  1908. _LockLayerRom(void *GfxBase, struct Layer *layer)
  1909. {
  1910. struct Caos    MyCaos;
  1911.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1912. //    MyCaos.M68kStart    =    NULL;
  1913. //    MyCaos.M68kSize        =    0;
  1914.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1915. //    MyCaos.PPCStart        =    NULL;
  1916. //    MyCaos.PPCSize        =    0;
  1917.     MyCaos.a5        =(ULONG) layer;
  1918.     MyCaos.caos_Un.Offset    =    (-432);
  1919.     MyCaos.a6        =(ULONG) GfxBase;    
  1920.     PPCCallOS(&MyCaos);
  1921. }
  1922.  
  1923. #define    MakeVPort(view, vp)    _MakeVPort(GRAPHICS_BASE_NAME, view, vp)
  1924.  
  1925. static __inline ULONG
  1926. _MakeVPort(void *GfxBase, struct View *view, struct ViewPort *vp)
  1927. {
  1928. struct Caos    MyCaos;
  1929.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1930. //    MyCaos.M68kStart    =    NULL;
  1931. //    MyCaos.M68kSize        =    0;
  1932.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1933. //    MyCaos.PPCStart        =    NULL;
  1934. //    MyCaos.PPCSize        =    0;
  1935.     MyCaos.a0        =(ULONG) view;
  1936.     MyCaos.a1        =(ULONG) vp;
  1937.     MyCaos.caos_Un.Offset    =    (-216);
  1938.     MyCaos.a6        =(ULONG) GfxBase;    
  1939.     return((ULONG)PPCCallOS(&MyCaos));
  1940. }
  1941.  
  1942. #define    ModeNotAvailable(modeID)    _ModeNotAvailable(GRAPHICS_BASE_NAME, modeID)
  1943.  
  1944. static __inline LONG
  1945. _ModeNotAvailable(void *GfxBase, unsigned long modeID)
  1946. {
  1947. struct Caos    MyCaos;
  1948.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1949. //    MyCaos.M68kStart    =    NULL;
  1950. //    MyCaos.M68kSize        =    0;
  1951.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1952. //    MyCaos.PPCStart        =    NULL;
  1953. //    MyCaos.PPCSize        =    0;
  1954.     MyCaos.d0        =(ULONG) modeID;
  1955.     MyCaos.caos_Un.Offset    =    (-798);
  1956.     MyCaos.a6        =(ULONG) GfxBase;    
  1957.     return((LONG)PPCCallOS(&MyCaos));
  1958. }
  1959.  
  1960. #define    Move(rp, x, y)    _Move(GRAPHICS_BASE_NAME, rp, x, y)
  1961.  
  1962. static __inline void
  1963. _Move(void *GfxBase, struct RastPort *rp, long x, long y)
  1964. {
  1965. struct Caos    MyCaos;
  1966.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1967. //    MyCaos.M68kStart    =    NULL;
  1968. //    MyCaos.M68kSize        =    0;
  1969.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1970. //    MyCaos.PPCStart        =    NULL;
  1971. //    MyCaos.PPCSize        =    0;
  1972.     MyCaos.a1        =(ULONG) rp;
  1973.     MyCaos.d0        =(ULONG) x;
  1974.     MyCaos.d1        =(ULONG) y;
  1975.     MyCaos.caos_Un.Offset    =    (-240);
  1976.     MyCaos.a6        =(ULONG) GfxBase;    
  1977.     PPCCallOS(&MyCaos);
  1978. }
  1979.  
  1980. #define    MoveSprite(vp, sprite, x, y)    _MoveSprite(GRAPHICS_BASE_NAME, vp, sprite, x, y)
  1981.  
  1982. static __inline void
  1983. _MoveSprite(void *GfxBase, struct ViewPort *vp, struct SimpleSprite *sprite, long x, long y)
  1984. {
  1985. struct Caos    MyCaos;
  1986.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1987. //    MyCaos.M68kStart    =    NULL;
  1988. //    MyCaos.M68kSize        =    0;
  1989.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1990. //    MyCaos.PPCStart        =    NULL;
  1991. //    MyCaos.PPCSize        =    0;
  1992.     MyCaos.a0        =(ULONG) vp;
  1993.     MyCaos.a1        =(ULONG) sprite;
  1994.     MyCaos.d0        =(ULONG) x;
  1995.     MyCaos.d1        =(ULONG) y;
  1996.     MyCaos.caos_Un.Offset    =    (-426);
  1997.     MyCaos.a6        =(ULONG) GfxBase;    
  1998.     PPCCallOS(&MyCaos);
  1999. }
  2000.  
  2001. #define    MrgCop(view)    _MrgCop(GRAPHICS_BASE_NAME, view)
  2002.  
  2003. static __inline ULONG
  2004. _MrgCop(void *GfxBase, struct View *view)
  2005. {
  2006. struct Caos    MyCaos;
  2007.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2008. //    MyCaos.M68kStart    =    NULL;
  2009. //    MyCaos.M68kSize        =    0;
  2010.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2011. //    MyCaos.PPCStart        =    NULL;
  2012. //    MyCaos.PPCSize        =    0;
  2013.     MyCaos.a1        =(ULONG) view;
  2014.     MyCaos.caos_Un.Offset    =    (-210);
  2015.     MyCaos.a6        =(ULONG) GfxBase;    
  2016.     return((ULONG)PPCCallOS(&MyCaos));
  2017. }
  2018.  
  2019. #define    NewRegion()    _NewRegion(GRAPHICS_BASE_NAME)
  2020.  
  2021. static __inline struct Region *
  2022. _NewRegion(void *GfxBase)
  2023. {
  2024. struct Caos    MyCaos;
  2025.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2026. //    MyCaos.M68kStart    =    NULL;
  2027. //    MyCaos.M68kSize        =    0;
  2028.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2029. //    MyCaos.PPCStart        =    NULL;
  2030. //    MyCaos.PPCSize        =    0;
  2031.     MyCaos.caos_Un.Offset    =    (-516);
  2032.     MyCaos.a6        =(ULONG) GfxBase;    
  2033.     return((struct Region *)PPCCallOS(&MyCaos));
  2034. }
  2035.  
  2036. #define    NextDisplayInfo(displayID)    _NextDisplayInfo(GRAPHICS_BASE_NAME, displayID)
  2037.  
  2038. static __inline ULONG
  2039. _NextDisplayInfo(void *GfxBase, unsigned long displayID)
  2040. {
  2041. struct Caos    MyCaos;
  2042.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2043. //    MyCaos.M68kStart    =    NULL;
  2044. //    MyCaos.M68kSize        =    0;
  2045.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2046. //    MyCaos.PPCStart        =    NULL;
  2047. //    MyCaos.PPCSize        =    0;
  2048.     MyCaos.d0        =(ULONG) displayID;
  2049.     MyCaos.caos_Un.Offset    =    (-732);
  2050.     MyCaos.a6        =(ULONG) GfxBase;    
  2051.     return((ULONG)PPCCallOS(&MyCaos));
  2052. }
  2053.  
  2054. #define    ObtainBestPenA(cm, r, g, b, tags)    _ObtainBestPenA(GRAPHICS_BASE_NAME, cm, r, g, b, tags)
  2055.  
  2056. static __inline LONG
  2057. _ObtainBestPenA(void *GfxBase, struct ColorMap *cm, unsigned long r, unsigned long g, unsigned long b, struct TagItem *tags)
  2058. {
  2059. struct Caos    MyCaos;
  2060.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2061. //    MyCaos.M68kStart    =    NULL;
  2062. //    MyCaos.M68kSize        =    0;
  2063.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2064. //    MyCaos.PPCStart        =    NULL;
  2065. //    MyCaos.PPCSize        =    0;
  2066.     MyCaos.a0        =(ULONG) cm;
  2067.     MyCaos.d1        =(ULONG) r;
  2068.     MyCaos.d2        =(ULONG) g;
  2069.     MyCaos.d3        =(ULONG) b;
  2070.     MyCaos.a1        =(ULONG) tags;
  2071.     MyCaos.caos_Un.Offset    =    (-840);
  2072.     MyCaos.a6        =(ULONG) GfxBase;    
  2073.     return((LONG)PPCCallOS(&MyCaos));
  2074. }
  2075.  
  2076. #ifndef NO_PPCINLINE_STDARG
  2077. #define ObtainBestPen(a0, a1, a2, a3, tags...) \
  2078.     ({ULONG _tags[] = { tags }; ObtainBestPenA((a0), (a1), (a2), (a3), (struct TagItem *)_tags);})
  2079. #endif /* !NO_PPCINLINE_STDARG */
  2080.  
  2081. #define    ObtainPen(cm, n, r, g, b, f)    _ObtainPen(GRAPHICS_BASE_NAME, cm, n, r, g, b, f)
  2082.  
  2083. static __inline ULONG
  2084. _ObtainPen(void *GfxBase, struct ColorMap *cm, unsigned long n, unsigned long r, unsigned long g, unsigned long b, long f)
  2085. {
  2086. struct Caos    MyCaos;
  2087.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2088. //    MyCaos.M68kStart    =    NULL;
  2089. //    MyCaos.M68kSize        =    0;
  2090.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2091. //    MyCaos.PPCStart        =    NULL;
  2092. //    MyCaos.PPCSize        =    0;
  2093.     MyCaos.a0        =(ULONG) cm;
  2094.     MyCaos.d0        =(ULONG) n;
  2095.     MyCaos.d1        =(ULONG) r;
  2096.     MyCaos.d2        =(ULONG) g;
  2097.     MyCaos.d3        =(ULONG) b;
  2098.     MyCaos.d4        =(ULONG) f;
  2099.     MyCaos.caos_Un.Offset    =    (-954);
  2100.     MyCaos.a6        =(ULONG) GfxBase;    
  2101.     return((ULONG)PPCCallOS(&MyCaos));
  2102. }
  2103.  
  2104. #define    OpenFont(textAttr)    _OpenFont(GRAPHICS_BASE_NAME, textAttr)
  2105.  
  2106. static __inline struct TextFont *
  2107. _OpenFont(void *GfxBase, struct TextAttr *textAttr)
  2108. {
  2109. struct Caos    MyCaos;
  2110.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2111. //    MyCaos.M68kStart    =    NULL;
  2112. //    MyCaos.M68kSize        =    0;
  2113.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2114. //    MyCaos.PPCStart        =    NULL;
  2115. //    MyCaos.PPCSize        =    0;
  2116.     MyCaos.a0        =(ULONG) textAttr;
  2117.     MyCaos.caos_Un.Offset    =    (-72);
  2118.     MyCaos.a6        =(ULONG) GfxBase;    
  2119.     return((struct TextFont *)PPCCallOS(&MyCaos));
  2120. }
  2121.  
  2122. #define    OpenMonitor(monitorName, displayID)    _OpenMonitor(GRAPHICS_BASE_NAME, monitorName, displayID)
  2123.  
  2124. static __inline struct MonitorSpec *
  2125. _OpenMonitor(void *GfxBase, STRPTR monitorName, unsigned long displayID)
  2126. {
  2127. struct Caos    MyCaos;
  2128.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2129. //    MyCaos.M68kStart    =    NULL;
  2130. //    MyCaos.M68kSize        =    0;
  2131.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2132. //    MyCaos.PPCStart        =    NULL;
  2133. //    MyCaos.PPCSize        =    0;
  2134.     MyCaos.a1        =(ULONG) monitorName;
  2135.     MyCaos.d0        =(ULONG) displayID;
  2136.     MyCaos.caos_Un.Offset    =    (-714);
  2137.     MyCaos.a6        =(ULONG) GfxBase;    
  2138.     return((struct MonitorSpec *)PPCCallOS(&MyCaos));
  2139. }
  2140.  
  2141. #define    OrRectRegion(region, rectangle)    _OrRectRegion(GRAPHICS_BASE_NAME, region, rectangle)
  2142.  
  2143. static __inline BOOL
  2144. _OrRectRegion(void *GfxBase, struct Region *region, struct Rectangle *rectangle)
  2145. {
  2146. struct Caos    MyCaos;
  2147.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2148. //    MyCaos.M68kStart    =    NULL;
  2149. //    MyCaos.M68kSize        =    0;
  2150.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2151. //    MyCaos.PPCStart        =    NULL;
  2152. //    MyCaos.PPCSize        =    0;
  2153.     MyCaos.a0        =(ULONG) region;
  2154.     MyCaos.a1        =(ULONG) rectangle;
  2155.     MyCaos.caos_Un.Offset    =    (-510);
  2156.     MyCaos.a6        =(ULONG) GfxBase;    
  2157.     return((BOOL)PPCCallOS(&MyCaos));
  2158. }
  2159.  
  2160. #define    OrRegionRegion(srcRegion, destRegion)    _OrRegionRegion(GRAPHICS_BASE_NAME, srcRegion, destRegion)
  2161.  
  2162. static __inline BOOL
  2163. _OrRegionRegion(void *GfxBase, struct Region *srcRegion, struct Region *destRegion)
  2164. {
  2165. struct Caos    MyCaos;
  2166.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2167. //    MyCaos.M68kStart    =    NULL;
  2168. //    MyCaos.M68kSize        =    0;
  2169.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2170. //    MyCaos.PPCStart        =    NULL;
  2171. //    MyCaos.PPCSize        =    0;
  2172.     MyCaos.a0        =(ULONG) srcRegion;
  2173.     MyCaos.a1        =(ULONG) destRegion;
  2174.     MyCaos.caos_Un.Offset    =    (-612);
  2175.     MyCaos.a6        =(ULONG) GfxBase;    
  2176.     return((BOOL)PPCCallOS(&MyCaos));
  2177. }
  2178.  
  2179. #define    OwnBlitter()    _OwnBlitter(GRAPHICS_BASE_NAME)
  2180.  
  2181. static __inline void
  2182. _OwnBlitter(void *GfxBase)
  2183. {
  2184. struct Caos    MyCaos;
  2185.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2186. //    MyCaos.M68kStart    =    NULL;
  2187. //    MyCaos.M68kSize        =    0;
  2188.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2189. //    MyCaos.PPCStart        =    NULL;
  2190. //    MyCaos.PPCSize        =    0;
  2191.     MyCaos.caos_Un.Offset    =    (-456);
  2192.     MyCaos.a6        =(ULONG) GfxBase;    
  2193.     PPCCallOS(&MyCaos);
  2194. }
  2195.  
  2196. #define    PolyDraw(rp, count, polyTable)    _PolyDraw(GRAPHICS_BASE_NAME, rp, count, polyTable)
  2197.  
  2198. static __inline void
  2199. _PolyDraw(void *GfxBase, struct RastPort *rp, long count, WORD *polyTable)
  2200. {
  2201. struct Caos    MyCaos;
  2202.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2203. //    MyCaos.M68kStart    =    NULL;
  2204. //    MyCaos.M68kSize        =    0;
  2205.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2206. //    MyCaos.PPCStart        =    NULL;
  2207. //    MyCaos.PPCSize        =    0;
  2208.     MyCaos.a1        =(ULONG) rp;
  2209.     MyCaos.d0        =(ULONG) count;
  2210.     MyCaos.a0        =(ULONG) polyTable;
  2211.     MyCaos.caos_Un.Offset    =    (-336);
  2212.     MyCaos.a6        =(ULONG) GfxBase;    
  2213.     PPCCallOS(&MyCaos);
  2214. }
  2215.  
  2216. #define    QBSBlit(blit)    _QBSBlit(GRAPHICS_BASE_NAME, blit)
  2217.  
  2218. static __inline void
  2219. _QBSBlit(void *GfxBase, struct bltnode *blit)
  2220. {
  2221. struct Caos    MyCaos;
  2222.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2223. //    MyCaos.M68kStart    =    NULL;
  2224. //    MyCaos.M68kSize        =    0;
  2225.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2226. //    MyCaos.PPCStart        =    NULL;
  2227. //    MyCaos.PPCSize        =    0;
  2228.     MyCaos.a1        =(ULONG) blit;
  2229.     MyCaos.caos_Un.Offset    =    (-294);
  2230.     MyCaos.a6        =(ULONG) GfxBase;    
  2231.     PPCCallOS(&MyCaos);
  2232. }
  2233.  
  2234. #define    QBlit(blit)    _QBlit(GRAPHICS_BASE_NAME, blit)
  2235.  
  2236. static __inline void
  2237. _QBlit(void *GfxBase, struct bltnode *blit)
  2238. {
  2239. struct Caos    MyCaos;
  2240.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2241. //    MyCaos.M68kStart    =    NULL;
  2242. //    MyCaos.M68kSize        =    0;
  2243.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2244. //    MyCaos.PPCStart        =    NULL;
  2245. //    MyCaos.PPCSize        =    0;
  2246.     MyCaos.a1        =(ULONG) blit;
  2247.     MyCaos.caos_Un.Offset    =    (-276);
  2248.     MyCaos.a6        =(ULONG) GfxBase;    
  2249.     PPCCallOS(&MyCaos);
  2250. }
  2251.  
  2252. #define    ReadPixel(rp, x, y)    _ReadPixel(GRAPHICS_BASE_NAME, rp, x, y)
  2253.  
  2254. static __inline ULONG
  2255. _ReadPixel(void *GfxBase, struct RastPort *rp, long x, long y)
  2256. {
  2257. struct Caos    MyCaos;
  2258.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2259. //    MyCaos.M68kStart    =    NULL;
  2260. //    MyCaos.M68kSize        =    0;
  2261.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2262. //    MyCaos.PPCStart        =    NULL;
  2263. //    MyCaos.PPCSize        =    0;
  2264.     MyCaos.a1        =(ULONG) rp;
  2265.     MyCaos.d0        =(ULONG) x;
  2266.     MyCaos.d1        =(ULONG) y;
  2267.     MyCaos.caos_Un.Offset    =    (-318);
  2268.     MyCaos.a6        =(ULONG) GfxBase;    
  2269.     return((ULONG)PPCCallOS(&MyCaos));
  2270. }
  2271.  
  2272. #define    ReadPixelArray8(rp, xstart, ystart, xstop, ystop, array, temprp)    _ReadPixelArray8(GRAPHICS_BASE_NAME, rp, xstart, ystart, xstop, ystop, array, temprp)
  2273.  
  2274. static __inline LONG
  2275. _ReadPixelArray8(void *GfxBase, struct RastPort *rp, unsigned long xstart, unsigned long ystart, unsigned long xstop, unsigned long ystop, UBYTE *array, struct RastPort *temprp)
  2276. {
  2277. struct Caos    MyCaos;
  2278.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2279. //    MyCaos.M68kStart    =    NULL;
  2280. //    MyCaos.M68kSize        =    0;
  2281.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2282. //    MyCaos.PPCStart        =    NULL;
  2283. //    MyCaos.PPCSize        =    0;
  2284.     MyCaos.a0        =(ULONG) rp;
  2285.     MyCaos.d0        =(ULONG) xstart;
  2286.     MyCaos.d1        =(ULONG) ystart;
  2287.     MyCaos.d2        =(ULONG) xstop;
  2288.     MyCaos.d3        =(ULONG) ystop;
  2289.     MyCaos.a2        =(ULONG) array;
  2290.     MyCaos.a1        =(ULONG) temprp;
  2291.     MyCaos.caos_Un.Offset    =    (-780);
  2292.     MyCaos.a6        =(ULONG) GfxBase;    
  2293.     return((LONG)PPCCallOS(&MyCaos));
  2294. }
  2295.  
  2296. #define    ReadPixelLine8(rp, xstart, ystart, width, array, tempRP)    _ReadPixelLine8(GRAPHICS_BASE_NAME, rp, xstart, ystart, width, array, tempRP)
  2297.  
  2298. static __inline LONG
  2299. _ReadPixelLine8(void *GfxBase, struct RastPort *rp, unsigned long xstart, unsigned long ystart, unsigned long width, UBYTE *array, struct RastPort *tempRP)
  2300. {
  2301. struct Caos    MyCaos;
  2302.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2303. //    MyCaos.M68kStart    =    NULL;
  2304. //    MyCaos.M68kSize        =    0;
  2305.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2306. //    MyCaos.PPCStart        =    NULL;
  2307. //    MyCaos.PPCSize        =    0;
  2308.     MyCaos.a0        =(ULONG) rp;
  2309.     MyCaos.d0        =(ULONG) xstart;
  2310.     MyCaos.d1        =(ULONG) ystart;
  2311.     MyCaos.d2        =(ULONG) width;
  2312.     MyCaos.a2        =(ULONG) array;
  2313.     MyCaos.a1        =(ULONG) tempRP;
  2314.     MyCaos.caos_Un.Offset    =    (-768);
  2315.     MyCaos.a6        =(ULONG) GfxBase;    
  2316.     return((LONG)PPCCallOS(&MyCaos));
  2317. }
  2318.  
  2319. #define    RectFill(rp, xMin, yMin, xMax, yMax)    _RectFill(GRAPHICS_BASE_NAME, rp, xMin, yMin, xMax, yMax)
  2320.  
  2321. static __inline void
  2322. _RectFill(void *GfxBase, struct RastPort *rp, long xMin, long yMin, long xMax, long yMax)
  2323. {
  2324. struct Caos    MyCaos;
  2325.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2326. //    MyCaos.M68kStart    =    NULL;
  2327. //    MyCaos.M68kSize        =    0;
  2328.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2329. //    MyCaos.PPCStart        =    NULL;
  2330. //    MyCaos.PPCSize        =    0;
  2331.     MyCaos.a1        =(ULONG) rp;
  2332.     MyCaos.d0        =(ULONG) xMin;
  2333.     MyCaos.d1        =(ULONG) yMin;
  2334.     MyCaos.d2        =(ULONG) xMax;
  2335.     MyCaos.d3        =(ULONG) yMax;
  2336.     MyCaos.caos_Un.Offset    =    (-306);
  2337.     MyCaos.a6        =(ULONG) GfxBase;    
  2338.     PPCCallOS(&MyCaos);
  2339. }
  2340.  
  2341. #define    ReleasePen(cm, n)    _ReleasePen(GRAPHICS_BASE_NAME, cm, n)
  2342.  
  2343. static __inline void
  2344. _ReleasePen(void *GfxBase, struct ColorMap *cm, unsigned long n)
  2345. {
  2346. struct Caos    MyCaos;
  2347.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2348. //    MyCaos.M68kStart    =    NULL;
  2349. //    MyCaos.M68kSize        =    0;
  2350.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2351. //    MyCaos.PPCStart        =    NULL;
  2352. //    MyCaos.PPCSize        =    0;
  2353.     MyCaos.a0        =(ULONG) cm;
  2354.     MyCaos.d0        =(ULONG) n;
  2355.     MyCaos.caos_Un.Offset    =    (-948);
  2356.     MyCaos.a6        =(ULONG) GfxBase;    
  2357.     PPCCallOS(&MyCaos);
  2358. }
  2359.  
  2360. #define    RemFont(textFont)    _RemFont(GRAPHICS_BASE_NAME, textFont)
  2361.  
  2362. static __inline void
  2363. _RemFont(void *GfxBase, struct TextFont *textFont)
  2364. {
  2365. struct Caos    MyCaos;
  2366.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2367. //    MyCaos.M68kStart    =    NULL;
  2368. //    MyCaos.M68kSize        =    0;
  2369.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2370. //    MyCaos.PPCStart        =    NULL;
  2371. //    MyCaos.PPCSize        =    0;
  2372.     MyCaos.a1        =(ULONG) textFont;
  2373.     MyCaos.caos_Un.Offset    =    (-486);
  2374.     MyCaos.a6        =(ULONG) GfxBase;    
  2375.     PPCCallOS(&MyCaos);
  2376. }
  2377.  
  2378. #define    RemIBob(bob, rp, vp)    _RemIBob(GRAPHICS_BASE_NAME, bob, rp, vp)
  2379.  
  2380. static __inline void
  2381. _RemIBob(void *GfxBase, struct Bob *bob, struct RastPort *rp, struct ViewPort *vp)
  2382. {
  2383. struct Caos    MyCaos;
  2384.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2385. //    MyCaos.M68kStart    =    NULL;
  2386. //    MyCaos.M68kSize        =    0;
  2387.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2388. //    MyCaos.PPCStart        =    NULL;
  2389. //    MyCaos.PPCSize        =    0;
  2390.     MyCaos.a0        =(ULONG) bob;
  2391.     MyCaos.a1        =(ULONG) rp;
  2392.     MyCaos.a2        =(ULONG) vp;
  2393.     MyCaos.caos_Un.Offset    =    (-132);
  2394.     MyCaos.a6        =(ULONG) GfxBase;    
  2395.     PPCCallOS(&MyCaos);
  2396. }
  2397.  
  2398. #define    RemVSprite(vSprite)    _RemVSprite(GRAPHICS_BASE_NAME, vSprite)
  2399.  
  2400. static __inline void
  2401. _RemVSprite(void *GfxBase, struct VSprite *vSprite)
  2402. {
  2403. struct Caos    MyCaos;
  2404.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2405. //    MyCaos.M68kStart    =    NULL;
  2406. //    MyCaos.M68kSize        =    0;
  2407.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2408. //    MyCaos.PPCStart        =    NULL;
  2409. //    MyCaos.PPCSize        =    0;
  2410.     MyCaos.a0        =(ULONG) vSprite;
  2411.     MyCaos.caos_Un.Offset    =    (-138);
  2412.     MyCaos.a6        =(ULONG) GfxBase;    
  2413.     PPCCallOS(&MyCaos);
  2414. }
  2415.  
  2416. #define    ScalerDiv(factor, numerator, denominator)    _ScalerDiv(GRAPHICS_BASE_NAME, factor, numerator, denominator)
  2417.  
  2418. static __inline UWORD
  2419. _ScalerDiv(void *GfxBase, unsigned long factor, unsigned long numerator, unsigned long denominator)
  2420. {
  2421. struct Caos    MyCaos;
  2422.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2423. //    MyCaos.M68kStart    =    NULL;
  2424. //    MyCaos.M68kSize        =    0;
  2425.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2426. //    MyCaos.PPCStart        =    NULL;
  2427. //    MyCaos.PPCSize        =    0;
  2428.     MyCaos.d0        =(ULONG) factor;
  2429.     MyCaos.d1        =(ULONG) numerator;
  2430.     MyCaos.d2        =(ULONG) denominator;
  2431.     MyCaos.caos_Un.Offset    =    (-684);
  2432.     MyCaos.a6        =(ULONG) GfxBase;    
  2433.     return((UWORD)PPCCallOS(&MyCaos));
  2434. }
  2435.  
  2436. #define    ScrollRaster(rp, dx, dy, xMin, yMin, xMax, yMax)    _ScrollRaster(GRAPHICS_BASE_NAME, rp, dx, dy, xMin, yMin, xMax, yMax)
  2437.  
  2438. static __inline void
  2439. _ScrollRaster(void *GfxBase, struct RastPort *rp, long dx, long dy, long xMin, long yMin, long xMax, long yMax)
  2440. {
  2441. struct Caos    MyCaos;
  2442.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2443. //    MyCaos.M68kStart    =    NULL;
  2444. //    MyCaos.M68kSize        =    0;
  2445.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2446. //    MyCaos.PPCStart        =    NULL;
  2447. //    MyCaos.PPCSize        =    0;
  2448.     MyCaos.a1        =(ULONG) rp;
  2449.     MyCaos.d0        =(ULONG) dx;
  2450.     MyCaos.d1        =(ULONG) dy;
  2451.     MyCaos.d2        =(ULONG) xMin;
  2452.     MyCaos.d3        =(ULONG) yMin;
  2453.     MyCaos.d4        =(ULONG) xMax;
  2454.     MyCaos.d5        =(ULONG) yMax;
  2455.     MyCaos.caos_Un.Offset    =    (-396);
  2456.     MyCaos.a6        =(ULONG) GfxBase;    
  2457.     PPCCallOS(&MyCaos);
  2458. }
  2459.  
  2460. #define    ScrollRasterBF(rp, dx, dy, xMin, yMin, xMax, yMax)    _ScrollRasterBF(GRAPHICS_BASE_NAME, rp, dx, dy, xMin, yMin, xMax, yMax)
  2461.  
  2462. static __inline void
  2463. _ScrollRasterBF(void *GfxBase, struct RastPort *rp, long dx, long dy, long xMin, long yMin, long xMax, long yMax)
  2464. {
  2465. struct Caos    MyCaos;
  2466.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2467. //    MyCaos.M68kStart    =    NULL;
  2468. //    MyCaos.M68kSize        =    0;
  2469.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2470. //    MyCaos.PPCStart        =    NULL;
  2471. //    MyCaos.PPCSize        =    0;
  2472.     MyCaos.a1        =(ULONG) rp;
  2473.     MyCaos.d0        =(ULONG) dx;
  2474.     MyCaos.d1        =(ULONG) dy;
  2475.     MyCaos.d2        =(ULONG) xMin;
  2476.     MyCaos.d3        =(ULONG) yMin;
  2477.     MyCaos.d4        =(ULONG) xMax;
  2478.     MyCaos.d5        =(ULONG) yMax;
  2479.     MyCaos.caos_Un.Offset    =    (-1002);
  2480.     MyCaos.a6        =(ULONG) GfxBase;    
  2481.     PPCCallOS(&MyCaos);
  2482. }
  2483.  
  2484. #define    ScrollVPort(vp)    _ScrollVPort(GRAPHICS_BASE_NAME, vp)
  2485.  
  2486. static __inline void
  2487. _ScrollVPort(void *GfxBase, struct ViewPort *vp)
  2488. {
  2489. struct Caos    MyCaos;
  2490.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2491. //    MyCaos.M68kStart    =    NULL;
  2492. //    MyCaos.M68kSize        =    0;
  2493.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2494. //    MyCaos.PPCStart        =    NULL;
  2495. //    MyCaos.PPCSize        =    0;
  2496.     MyCaos.a0        =(ULONG) vp;
  2497.     MyCaos.caos_Un.Offset    =    (-588);
  2498.     MyCaos.a6        =(ULONG) GfxBase;    
  2499.     PPCCallOS(&MyCaos);
  2500. }
  2501.  
  2502. #define    SetABPenDrMd(rp, apen, bpen, drawmode)    _SetABPenDrMd(GRAPHICS_BASE_NAME, rp, apen, bpen, drawmode)
  2503.  
  2504. static __inline void
  2505. _SetABPenDrMd(void *GfxBase, struct RastPort *rp, unsigned long apen, unsigned long bpen, unsigned long drawmode)
  2506. {
  2507. struct Caos    MyCaos;
  2508.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2509. //    MyCaos.M68kStart    =    NULL;
  2510. //    MyCaos.M68kSize        =    0;
  2511.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2512. //    MyCaos.PPCStart        =    NULL;
  2513. //    MyCaos.PPCSize        =    0;
  2514.     MyCaos.a1        =(ULONG) rp;
  2515.     MyCaos.d0        =(ULONG) apen;
  2516.     MyCaos.d1        =(ULONG) bpen;
  2517.     MyCaos.d2        =(ULONG) drawmode;
  2518.     MyCaos.caos_Un.Offset    =    (-894);
  2519.     MyCaos.a6        =(ULONG) GfxBase;    
  2520.     PPCCallOS(&MyCaos);
  2521. }
  2522.  
  2523. #define    SetAPen(rp, pen)    _SetAPen(GRAPHICS_BASE_NAME, rp, pen)
  2524.  
  2525. static __inline void
  2526. _SetAPen(void *GfxBase, struct RastPort *rp, unsigned long pen)
  2527. {
  2528. struct Caos    MyCaos;
  2529.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2530. //    MyCaos.M68kStart    =    NULL;
  2531. //    MyCaos.M68kSize        =    0;
  2532.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2533. //    MyCaos.PPCStart        =    NULL;
  2534. //    MyCaos.PPCSize        =    0;
  2535.     MyCaos.a1        =(ULONG) rp;
  2536.     MyCaos.d0        =(ULONG) pen;
  2537.     MyCaos.caos_Un.Offset    =    (-342);
  2538.     MyCaos.a6        =(ULONG) GfxBase;    
  2539.     PPCCallOS(&MyCaos);
  2540. }
  2541.  
  2542. #define    SetBPen(rp, pen)    _SetBPen(GRAPHICS_BASE_NAME, rp, pen)
  2543.  
  2544. static __inline void
  2545. _SetBPen(void *GfxBase, struct RastPort *rp, unsigned long pen)
  2546. {
  2547. struct Caos    MyCaos;
  2548.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2549. //    MyCaos.M68kStart    =    NULL;
  2550. //    MyCaos.M68kSize        =    0;
  2551.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2552. //    MyCaos.PPCStart        =    NULL;
  2553. //    MyCaos.PPCSize        =    0;
  2554.     MyCaos.a1        =(ULONG) rp;
  2555.     MyCaos.d0        =(ULONG) pen;
  2556.     MyCaos.caos_Un.Offset    =    (-348);
  2557.     MyCaos.a6        =(ULONG) GfxBase;    
  2558.     PPCCallOS(&MyCaos);
  2559. }
  2560.  
  2561. #define    SetChipRev(want)    _SetChipRev(GRAPHICS_BASE_NAME, want)
  2562.  
  2563. static __inline ULONG
  2564. _SetChipRev(void *GfxBase, unsigned long want)
  2565. {
  2566. struct Caos    MyCaos;
  2567.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2568. //    MyCaos.M68kStart    =    NULL;
  2569. //    MyCaos.M68kSize        =    0;
  2570.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2571. //    MyCaos.PPCStart        =    NULL;
  2572. //    MyCaos.PPCSize        =    0;
  2573.     MyCaos.d0        =(ULONG) want;
  2574.     MyCaos.caos_Un.Offset    =    (-888);
  2575.     MyCaos.a6        =(ULONG) GfxBase;    
  2576.     return((ULONG)PPCCallOS(&MyCaos));
  2577. }
  2578.  
  2579. #define    SetCollision(num, routine, gelsInfo)    _SetCollision(GRAPHICS_BASE_NAME, num, routine, gelsInfo)
  2580.  
  2581. static __inline void
  2582. _SetCollision(void *GfxBase, unsigned long num, void (*routine)(struct VSprite *vSprite, APTR), struct GelsInfo *gelsInfo)
  2583. {
  2584. struct Caos    MyCaos;
  2585.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2586. //    MyCaos.M68kStart    =    NULL;
  2587. //    MyCaos.M68kSize        =    0;
  2588.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2589. //    MyCaos.PPCStart        =    NULL;
  2590. //    MyCaos.PPCSize        =    0;
  2591.     MyCaos.d0        =(ULONG) num;
  2592.     MyCaos.a0        =(ULONG) routine;
  2593.     MyCaos.a1        =(ULONG) gelsInfo;
  2594.     MyCaos.caos_Un.Offset    =    (-144);
  2595.     MyCaos.a6        =(ULONG) GfxBase;    
  2596.     PPCCallOS(&MyCaos);
  2597. }
  2598.  
  2599. #define    SetDrMd(rp, drawMode)    _SetDrMd(GRAPHICS_BASE_NAME, rp, drawMode)
  2600.  
  2601. static __inline void
  2602. _SetDrMd(void *GfxBase, struct RastPort *rp, unsigned long drawMode)
  2603. {
  2604. struct Caos    MyCaos;
  2605.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2606. //    MyCaos.M68kStart    =    NULL;
  2607. //    MyCaos.M68kSize        =    0;
  2608.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2609. //    MyCaos.PPCStart        =    NULL;
  2610. //    MyCaos.PPCSize        =    0;
  2611.     MyCaos.a1        =(ULONG) rp;
  2612.     MyCaos.d0        =(ULONG) drawMode;
  2613.     MyCaos.caos_Un.Offset    =    (-354);
  2614.     MyCaos.a6        =(ULONG) GfxBase;    
  2615.     PPCCallOS(&MyCaos);
  2616. }
  2617.  
  2618. #define    SetFont(rp, textFont)    _SetFont(GRAPHICS_BASE_NAME, rp, textFont)
  2619.  
  2620. static __inline LONG
  2621. _SetFont(void *GfxBase, struct RastPort *rp, struct TextFont *textFont)
  2622. {
  2623. struct Caos    MyCaos;
  2624.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2625. //    MyCaos.M68kStart    =    NULL;
  2626. //    MyCaos.M68kSize        =    0;
  2627.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2628. //    MyCaos.PPCStart        =    NULL;
  2629. //    MyCaos.PPCSize        =    0;
  2630.     MyCaos.a1        =(ULONG) rp;
  2631.     MyCaos.a0        =(ULONG) textFont;
  2632.     MyCaos.caos_Un.Offset    =    (-66);
  2633.     MyCaos.a6        =(ULONG) GfxBase;    
  2634.     return((LONG)PPCCallOS(&MyCaos));
  2635. }
  2636.  
  2637. #define    SetMaxPen(rp, maxpen)    _SetMaxPen(GRAPHICS_BASE_NAME, rp, maxpen)
  2638.  
  2639. static __inline void
  2640. _SetMaxPen(void *GfxBase, struct RastPort *rp, unsigned long maxpen)
  2641. {
  2642. struct Caos    MyCaos;
  2643.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2644. //    MyCaos.M68kStart    =    NULL;
  2645. //    MyCaos.M68kSize        =    0;
  2646.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2647. //    MyCaos.PPCStart        =    NULL;
  2648. //    MyCaos.PPCSize        =    0;
  2649.     MyCaos.a0        =(ULONG) rp;
  2650.     MyCaos.d0        =(ULONG) maxpen;
  2651.     MyCaos.caos_Un.Offset    =    (-990);
  2652.     MyCaos.a6        =(ULONG) GfxBase;    
  2653.     PPCCallOS(&MyCaos);
  2654. }
  2655.  
  2656. #define    SetOutlinePen(rp, pen)    _SetOutlinePen(GRAPHICS_BASE_NAME, rp, pen)
  2657.  
  2658. static __inline ULONG
  2659. _SetOutlinePen(void *GfxBase, struct RastPort *rp, unsigned long pen)
  2660. {
  2661. struct Caos    MyCaos;
  2662.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2663. //    MyCaos.M68kStart    =    NULL;
  2664. //    MyCaos.M68kSize        =    0;
  2665.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2666. //    MyCaos.PPCStart        =    NULL;
  2667. //    MyCaos.PPCSize        =    0;
  2668.     MyCaos.a0        =(ULONG) rp;
  2669.     MyCaos.d0        =(ULONG) pen;
  2670.     MyCaos.caos_Un.Offset    =    (-978);
  2671.     MyCaos.a6        =(ULONG) GfxBase;    
  2672.     return((ULONG)PPCCallOS(&MyCaos));
  2673. }
  2674.  
  2675. #define    SetRGB32(vp, n, r, g, b)    _SetRGB32(GRAPHICS_BASE_NAME, vp, n, r, g, b)
  2676.  
  2677. static __inline void
  2678. _SetRGB32(void *GfxBase, struct ViewPort *vp, unsigned long n, unsigned long r, unsigned long g, unsigned long b)
  2679. {
  2680. struct Caos    MyCaos;
  2681.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2682. //    MyCaos.M68kStart    =    NULL;
  2683. //    MyCaos.M68kSize        =    0;
  2684.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2685. //    MyCaos.PPCStart        =    NULL;
  2686. //    MyCaos.PPCSize        =    0;
  2687.     MyCaos.a0        =(ULONG) vp;
  2688.     MyCaos.d0        =(ULONG) n;
  2689.     MyCaos.d1        =(ULONG) r;
  2690.     MyCaos.d2        =(ULONG) g;
  2691.     MyCaos.d3        =(ULONG) b;
  2692.     MyCaos.caos_Un.Offset    =    (-852);
  2693.     MyCaos.a6        =(ULONG) GfxBase;    
  2694.     PPCCallOS(&MyCaos);
  2695. }
  2696.  
  2697. #define    SetRGB32CM(cm, n, r, g, b)    _SetRGB32CM(GRAPHICS_BASE_NAME, cm, n, r, g, b)
  2698.  
  2699. static __inline void
  2700. _SetRGB32CM(void *GfxBase, struct ColorMap *cm, unsigned long n, unsigned long r, unsigned long g, unsigned long b)
  2701. {
  2702. struct Caos    MyCaos;
  2703.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2704. //    MyCaos.M68kStart    =    NULL;
  2705. //    MyCaos.M68kSize        =    0;
  2706.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2707. //    MyCaos.PPCStart        =    NULL;
  2708. //    MyCaos.PPCSize        =    0;
  2709.     MyCaos.a0        =(ULONG) cm;
  2710.     MyCaos.d0        =(ULONG) n;
  2711.     MyCaos.d1        =(ULONG) r;
  2712.     MyCaos.d2        =(ULONG) g;
  2713.     MyCaos.d3        =(ULONG) b;
  2714.     MyCaos.caos_Un.Offset    =    (-996);
  2715.     MyCaos.a6        =(ULONG) GfxBase;    
  2716.     PPCCallOS(&MyCaos);
  2717. }
  2718.  
  2719. #define    SetRGB4(vp, index, red, green, blue)    _SetRGB4(GRAPHICS_BASE_NAME, vp, index, red, green, blue)
  2720.  
  2721. static __inline void
  2722. _SetRGB4(void *GfxBase, struct ViewPort *vp, long index, unsigned long red, unsigned long green, unsigned long blue)
  2723. {
  2724. struct Caos    MyCaos;
  2725.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2726. //    MyCaos.M68kStart    =    NULL;
  2727. //    MyCaos.M68kSize        =    0;
  2728.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2729. //    MyCaos.PPCStart        =    NULL;
  2730. //    MyCaos.PPCSize        =    0;
  2731.     MyCaos.a0        =(ULONG) vp;
  2732.     MyCaos.d0        =(ULONG) index;
  2733.     MyCaos.d1        =(ULONG) red;
  2734.     MyCaos.d2        =(ULONG) green;
  2735.     MyCaos.d3        =(ULONG) blue;
  2736.     MyCaos.caos_Un.Offset    =    (-288);
  2737.     MyCaos.a6        =(ULONG) GfxBase;    
  2738.     PPCCallOS(&MyCaos);
  2739. }
  2740.  
  2741. #define    SetRGB4CM(colorMap, index, red, green, blue)    _SetRGB4CM(GRAPHICS_BASE_NAME, colorMap, index, red, green, blue)
  2742.  
  2743. static __inline void
  2744. _SetRGB4CM(void *GfxBase, struct ColorMap *colorMap, long index, unsigned long red, unsigned long green, unsigned long blue)
  2745. {
  2746. struct Caos    MyCaos;
  2747.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2748. //    MyCaos.M68kStart    =    NULL;
  2749. //    MyCaos.M68kSize        =    0;
  2750.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2751. //    MyCaos.PPCStart        =    NULL;
  2752. //    MyCaos.PPCSize        =    0;
  2753.     MyCaos.a0        =(ULONG) colorMap;
  2754.     MyCaos.d0        =(ULONG) index;
  2755.     MyCaos.d1        =(ULONG) red;
  2756.     MyCaos.d2        =(ULONG) green;
  2757.     MyCaos.d3        =(ULONG) blue;
  2758.     MyCaos.caos_Un.Offset    =    (-630);
  2759.     MyCaos.a6        =(ULONG) GfxBase;    
  2760.     PPCCallOS(&MyCaos);
  2761. }
  2762.  
  2763. #define    SetRPAttrsA(rp, tags)    _SetRPAttrsA(GRAPHICS_BASE_NAME, rp, tags)
  2764.  
  2765. static __inline void
  2766. _SetRPAttrsA(void *GfxBase, struct RastPort *rp, struct TagItem *tags)
  2767. {
  2768. struct Caos    MyCaos;
  2769.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2770. //    MyCaos.M68kStart    =    NULL;
  2771. //    MyCaos.M68kSize        =    0;
  2772.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2773. //    MyCaos.PPCStart        =    NULL;
  2774. //    MyCaos.PPCSize        =    0;
  2775.     MyCaos.a0        =(ULONG) rp;
  2776.     MyCaos.a1        =(ULONG) tags;
  2777.     MyCaos.caos_Un.Offset    =    (-1038);
  2778.     MyCaos.a6        =(ULONG) GfxBase;    
  2779.     PPCCallOS(&MyCaos);
  2780. }
  2781.  
  2782. #ifndef NO_PPCINLINE_STDARG
  2783. #define SetRPAttrs(a0, tags...) \
  2784.     ({ULONG _tags[] = { tags }; SetRPAttrsA((a0), (struct TagItem *)_tags);})
  2785. #endif /* !NO_PPCINLINE_STDARG */
  2786.  
  2787. #define    SetRast(rp, pen)    _SetRast(GRAPHICS_BASE_NAME, rp, pen)
  2788.  
  2789. static __inline void
  2790. _SetRast(void *GfxBase, struct RastPort *rp, unsigned long pen)
  2791. {
  2792. struct Caos    MyCaos;
  2793.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2794. //    MyCaos.M68kStart    =    NULL;
  2795. //    MyCaos.M68kSize        =    0;
  2796.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2797. //    MyCaos.PPCStart        =    NULL;
  2798. //    MyCaos.PPCSize        =    0;
  2799.     MyCaos.a1        =(ULONG) rp;
  2800.     MyCaos.d0        =(ULONG) pen;
  2801.     MyCaos.caos_Un.Offset    =    (-234);
  2802.     MyCaos.a6        =(ULONG) GfxBase;    
  2803.     PPCCallOS(&MyCaos);
  2804. }
  2805.  
  2806. #define    SetSoftStyle(rp, style, enable)    _SetSoftStyle(GRAPHICS_BASE_NAME, rp, style, enable)
  2807.  
  2808. static __inline ULONG
  2809. _SetSoftStyle(void *GfxBase, struct RastPort *rp, unsigned long style, unsigned long enable)
  2810. {
  2811. struct Caos    MyCaos;
  2812.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2813. //    MyCaos.M68kStart    =    NULL;
  2814. //    MyCaos.M68kSize        =    0;
  2815.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2816. //    MyCaos.PPCStart        =    NULL;
  2817. //    MyCaos.PPCSize        =    0;
  2818.     MyCaos.a1        =(ULONG) rp;
  2819.     MyCaos.d0        =(ULONG) style;
  2820.     MyCaos.d1        =(ULONG) enable;
  2821.     MyCaos.caos_Un.Offset    =    (-90);
  2822.     MyCaos.a6        =(ULONG) GfxBase;    
  2823.     return((ULONG)PPCCallOS(&MyCaos));
  2824. }
  2825.  
  2826. #define    SetWriteMask(rp, msk)    _SetWriteMask(GRAPHICS_BASE_NAME, rp, msk)
  2827.  
  2828. static __inline ULONG
  2829. _SetWriteMask(void *GfxBase, struct RastPort *rp, unsigned long msk)
  2830. {
  2831. struct Caos    MyCaos;
  2832.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2833. //    MyCaos.M68kStart    =    NULL;
  2834. //    MyCaos.M68kSize        =    0;
  2835.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2836. //    MyCaos.PPCStart        =    NULL;
  2837. //    MyCaos.PPCSize        =    0;
  2838.     MyCaos.a0        =(ULONG) rp;
  2839.     MyCaos.d0        =(ULONG) msk;
  2840.     MyCaos.caos_Un.Offset    =    (-984);
  2841.     MyCaos.a6        =(ULONG) GfxBase;    
  2842.     return((ULONG)PPCCallOS(&MyCaos));
  2843. }
  2844.  
  2845. #define    SortGList(rp)    _SortGList(GRAPHICS_BASE_NAME, rp)
  2846.  
  2847. static __inline void
  2848. _SortGList(void *GfxBase, struct RastPort *rp)
  2849. {
  2850. struct Caos    MyCaos;
  2851.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2852. //    MyCaos.M68kStart    =    NULL;
  2853. //    MyCaos.M68kSize        =    0;
  2854.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2855. //    MyCaos.PPCStart        =    NULL;
  2856. //    MyCaos.PPCSize        =    0;
  2857.     MyCaos.a1        =(ULONG) rp;
  2858.     MyCaos.caos_Un.Offset    =    (-150);
  2859.     MyCaos.a6        =(ULONG) GfxBase;    
  2860.     PPCCallOS(&MyCaos);
  2861. }
  2862.  
  2863. #define    StripFont(font)    _StripFont(GRAPHICS_BASE_NAME, font)
  2864.  
  2865. static __inline void
  2866. _StripFont(void *GfxBase, struct TextFont *font)
  2867. {
  2868. struct Caos    MyCaos;
  2869.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2870. //    MyCaos.M68kStart    =    NULL;
  2871. //    MyCaos.M68kSize        =    0;
  2872.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2873. //    MyCaos.PPCStart        =    NULL;
  2874. //    MyCaos.PPCSize        =    0;
  2875.     MyCaos.a0        =(ULONG) font;
  2876.     MyCaos.caos_Un.Offset    =    (-822);
  2877.     MyCaos.a6        =(ULONG) GfxBase;    
  2878.     PPCCallOS(&MyCaos);
  2879. }
  2880.  
  2881. #define    SyncSBitMap(layer)    _SyncSBitMap(GRAPHICS_BASE_NAME, layer)
  2882.  
  2883. static __inline void
  2884. _SyncSBitMap(void *GfxBase, struct Layer *layer)
  2885. {
  2886. struct Caos    MyCaos;
  2887.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2888. //    MyCaos.M68kStart    =    NULL;
  2889. //    MyCaos.M68kSize        =    0;
  2890.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2891. //    MyCaos.PPCStart        =    NULL;
  2892. //    MyCaos.PPCSize        =    0;
  2893.     MyCaos.a0        =(ULONG) layer;
  2894.     MyCaos.caos_Un.Offset    =    (-444);
  2895.     MyCaos.a6        =(ULONG) GfxBase;    
  2896.     PPCCallOS(&MyCaos);
  2897. }
  2898.  
  2899. #define    Text(rp, string, count)    _Text(GRAPHICS_BASE_NAME, rp, string, count)
  2900.  
  2901. static __inline LONG
  2902. _Text(void *GfxBase, struct RastPort *rp, STRPTR string, unsigned long count)
  2903. {
  2904. struct Caos    MyCaos;
  2905.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2906. //    MyCaos.M68kStart    =    NULL;
  2907. //    MyCaos.M68kSize        =    0;
  2908.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2909. //    MyCaos.PPCStart        =    NULL;
  2910. //    MyCaos.PPCSize        =    0;
  2911.     MyCaos.a1        =(ULONG) rp;
  2912.     MyCaos.a0        =(ULONG) string;
  2913.     MyCaos.d0        =(ULONG) count;
  2914.     MyCaos.caos_Un.Offset    =    (-60);
  2915.     MyCaos.a6        =(ULONG) GfxBase;    
  2916.     return((LONG)PPCCallOS(&MyCaos));
  2917. }
  2918.  
  2919. #define    TextExtent(rp, string, count, textExtent)    _TextExtent(GRAPHICS_BASE_NAME, rp, string, count, textExtent)
  2920.  
  2921. static __inline WORD
  2922. _TextExtent(void *GfxBase, struct RastPort *rp, STRPTR string, long count, struct TextExtent *textExtent)
  2923. {
  2924. struct Caos    MyCaos;
  2925.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2926. //    MyCaos.M68kStart    =    NULL;
  2927. //    MyCaos.M68kSize        =    0;
  2928.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2929. //    MyCaos.PPCStart        =    NULL;
  2930. //    MyCaos.PPCSize        =    0;
  2931.     MyCaos.a1        =(ULONG) rp;
  2932.     MyCaos.a0        =(ULONG) string;
  2933.     MyCaos.d0        =(ULONG) count;
  2934.     MyCaos.a2        =(ULONG) textExtent;
  2935.     MyCaos.caos_Un.Offset    =    (-690);
  2936.     MyCaos.a6        =(ULONG) GfxBase;    
  2937.     return((WORD)PPCCallOS(&MyCaos));
  2938. }
  2939.  
  2940. #define    TextFit(rp, string, strLen, textExtent, constrainingExtent, strDirection, constrainingBitWidth, constrainingBitHeight)    _TextFit(GRAPHICS_BASE_NAME, rp, string, strLen, textExtent, constrainingExtent, strDirection, constrainingBitWidth, constrainingBitHeight)
  2941.  
  2942. static __inline ULONG
  2943. _TextFit(void *GfxBase, struct RastPort *rp, STRPTR string, unsigned long strLen, struct TextExtent *textExtent, struct TextExtent *constrainingExtent, long strDirection, unsigned long constrainingBitWidth, unsigned long constrainingBitHeight)
  2944. {
  2945. struct Caos    MyCaos;
  2946.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2947. //    MyCaos.M68kStart    =    NULL;
  2948. //    MyCaos.M68kSize        =    0;
  2949.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2950. //    MyCaos.PPCStart        =    NULL;
  2951. //    MyCaos.PPCSize        =    0;
  2952.     MyCaos.a1        =(ULONG) rp;
  2953.     MyCaos.a0        =(ULONG) string;
  2954.     MyCaos.d0        =(ULONG) strLen;
  2955.     MyCaos.a2        =(ULONG) textExtent;
  2956.     MyCaos.a3        =(ULONG) constrainingExtent;
  2957.     MyCaos.d1        =(ULONG) strDirection;
  2958.     MyCaos.d2        =(ULONG) constrainingBitWidth;
  2959.     MyCaos.d3        =(ULONG) constrainingBitHeight;
  2960.     MyCaos.caos_Un.Offset    =    (-696);
  2961.     MyCaos.a6        =(ULONG) GfxBase;    
  2962.     return((ULONG)PPCCallOS(&MyCaos));
  2963. }
  2964.  
  2965. #define    TextLength(rp, string, count)    _TextLength(GRAPHICS_BASE_NAME, rp, string, count)
  2966.  
  2967. static __inline WORD
  2968. _TextLength(void *GfxBase, struct RastPort *rp, STRPTR string, unsigned long count)
  2969. {
  2970. struct Caos    MyCaos;
  2971.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2972. //    MyCaos.M68kStart    =    NULL;
  2973. //    MyCaos.M68kSize        =    0;
  2974.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2975. //    MyCaos.PPCStart        =    NULL;
  2976. //    MyCaos.PPCSize        =    0;
  2977.     MyCaos.a1        =(ULONG) rp;
  2978.     MyCaos.a0        =(ULONG) string;
  2979.     MyCaos.d0        =(ULONG) count;
  2980.     MyCaos.caos_Un.Offset    =    (-54);
  2981.     MyCaos.a6        =(ULONG) GfxBase;    
  2982.     return((WORD)PPCCallOS(&MyCaos));
  2983. }
  2984.  
  2985. #define    UCopperListInit(uCopList, n)    _UCopperListInit(GRAPHICS_BASE_NAME, uCopList, n)
  2986.  
  2987. static __inline struct CopList *
  2988. _UCopperListInit(void *GfxBase, struct UCopList *uCopList, long n)
  2989. {
  2990. struct Caos    MyCaos;
  2991.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  2992. //    MyCaos.M68kStart    =    NULL;
  2993. //    MyCaos.M68kSize        =    0;
  2994.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  2995. //    MyCaos.PPCStart        =    NULL;
  2996. //    MyCaos.PPCSize        =    0;
  2997.     MyCaos.a0        =(ULONG) uCopList;
  2998.     MyCaos.d0        =(ULONG) n;
  2999.     MyCaos.caos_Un.Offset    =    (-594);
  3000.     MyCaos.a6        =(ULONG) GfxBase;    
  3001.     return((struct CopList *)PPCCallOS(&MyCaos));
  3002. }
  3003.  
  3004. #define    UnlockLayerRom(layer)    _UnlockLayerRom(GRAPHICS_BASE_NAME, layer)
  3005.  
  3006. static __inline void
  3007. _UnlockLayerRom(void *GfxBase, struct Layer *layer)
  3008. {
  3009. struct Caos    MyCaos;
  3010.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3011. //    MyCaos.M68kStart    =    NULL;
  3012. //    MyCaos.M68kSize        =    0;
  3013.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3014. //    MyCaos.PPCStart        =    NULL;
  3015. //    MyCaos.PPCSize        =    0;
  3016.     MyCaos.a5        =(ULONG) layer;
  3017.     MyCaos.caos_Un.Offset    =    (-438);
  3018.     MyCaos.a6        =(ULONG) GfxBase;    
  3019.     PPCCallOS(&MyCaos);
  3020. }
  3021.  
  3022. #define    VBeamPos()    _VBeamPos(GRAPHICS_BASE_NAME)
  3023.  
  3024. static __inline LONG
  3025. _VBeamPos(void *GfxBase)
  3026. {
  3027. struct Caos    MyCaos;
  3028.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3029. //    MyCaos.M68kStart    =    NULL;
  3030. //    MyCaos.M68kSize        =    0;
  3031.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3032. //    MyCaos.PPCStart        =    NULL;
  3033. //    MyCaos.PPCSize        =    0;
  3034.     MyCaos.caos_Un.Offset    =    (-384);
  3035.     MyCaos.a6        =(ULONG) GfxBase;    
  3036.     return((LONG)PPCCallOS(&MyCaos));
  3037. }
  3038.  
  3039. #define    VideoControl(colorMap, tagarray)    _VideoControl(GRAPHICS_BASE_NAME, colorMap, tagarray)
  3040.  
  3041. static __inline BOOL
  3042. _VideoControl(void *GfxBase, struct ColorMap *colorMap, struct TagItem *tagarray)
  3043. {
  3044. struct Caos    MyCaos;
  3045.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3046. //    MyCaos.M68kStart    =    NULL;
  3047. //    MyCaos.M68kSize        =    0;
  3048.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3049. //    MyCaos.PPCStart        =    NULL;
  3050. //    MyCaos.PPCSize        =    0;
  3051.     MyCaos.a0        =(ULONG) colorMap;
  3052.     MyCaos.a1        =(ULONG) tagarray;
  3053.     MyCaos.caos_Un.Offset    =    (-708);
  3054.     MyCaos.a6        =(ULONG) GfxBase;    
  3055.     return((BOOL)PPCCallOS(&MyCaos));
  3056. }
  3057.  
  3058. #ifndef NO_PPCINLINE_STDARG
  3059. #define VideoControlTags(a0, tags...) \
  3060.     ({ULONG _tags[] = { tags }; VideoControl((a0), (struct TagItem *)_tags);})
  3061. #endif /* !NO_PPCINLINE_STDARG */
  3062.  
  3063. #define    WaitBOVP(vp)    _WaitBOVP(GRAPHICS_BASE_NAME, vp)
  3064.  
  3065. static __inline void
  3066. _WaitBOVP(void *GfxBase, struct ViewPort *vp)
  3067. {
  3068. struct Caos    MyCaos;
  3069.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3070. //    MyCaos.M68kStart    =    NULL;
  3071. //    MyCaos.M68kSize        =    0;
  3072.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3073. //    MyCaos.PPCStart        =    NULL;
  3074. //    MyCaos.PPCSize        =    0;
  3075.     MyCaos.a0        =(ULONG) vp;
  3076.     MyCaos.caos_Un.Offset    =    (-402);
  3077.     MyCaos.a6        =(ULONG) GfxBase;    
  3078.     PPCCallOS(&MyCaos);
  3079. }
  3080.  
  3081. #define    WaitBlit()    _WaitBlit(GRAPHICS_BASE_NAME)
  3082.  
  3083. static __inline void
  3084. _WaitBlit(void *GfxBase)
  3085. {
  3086. struct Caos    MyCaos;
  3087.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3088. //    MyCaos.M68kStart    =    NULL;
  3089. //    MyCaos.M68kSize        =    0;
  3090.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3091. //    MyCaos.PPCStart        =    NULL;
  3092. //    MyCaos.PPCSize        =    0;
  3093.     MyCaos.caos_Un.Offset    =    (-228);
  3094.     MyCaos.a6        =(ULONG) GfxBase;    
  3095.     PPCCallOS(&MyCaos);
  3096. }
  3097.  
  3098. #define    WaitTOF()    _WaitTOF(GRAPHICS_BASE_NAME)
  3099.  
  3100. static __inline void
  3101. _WaitTOF(void *GfxBase)
  3102. {
  3103. struct Caos    MyCaos;
  3104.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3105. //    MyCaos.M68kStart    =    NULL;
  3106. //    MyCaos.M68kSize        =    0;
  3107.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3108. //    MyCaos.PPCStart        =    NULL;
  3109. //    MyCaos.PPCSize        =    0;
  3110.     MyCaos.caos_Un.Offset    =    (-270);
  3111.     MyCaos.a6        =(ULONG) GfxBase;    
  3112.     PPCCallOS(&MyCaos);
  3113. }
  3114.  
  3115. #define    WeighTAMatch(reqTextAttr, targetTextAttr, targetTags)    _WeighTAMatch(GRAPHICS_BASE_NAME, reqTextAttr, targetTextAttr, targetTags)
  3116.  
  3117. static __inline WORD
  3118. _WeighTAMatch(void *GfxBase, struct TextAttr *reqTextAttr, struct TextAttr *targetTextAttr, struct TagItem *targetTags)
  3119. {
  3120. struct Caos    MyCaos;
  3121.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3122. //    MyCaos.M68kStart    =    NULL;
  3123. //    MyCaos.M68kSize        =    0;
  3124.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3125. //    MyCaos.PPCStart        =    NULL;
  3126. //    MyCaos.PPCSize        =    0;
  3127.     MyCaos.a0        =(ULONG) reqTextAttr;
  3128.     MyCaos.a1        =(ULONG) targetTextAttr;
  3129.     MyCaos.a2        =(ULONG) targetTags;
  3130.     MyCaos.caos_Un.Offset    =    (-804);
  3131.     MyCaos.a6        =(ULONG) GfxBase;    
  3132.     return((WORD)PPCCallOS(&MyCaos));
  3133. }
  3134.  
  3135. #ifndef NO_PPCINLINE_STDARG
  3136. #define WeighTAMatchTags(a0, a1, tags...) \
  3137.     ({ULONG _tags[] = { tags }; WeighTAMatch((a0), (a1), (struct TagItem *)_tags);})
  3138. #endif /* !NO_PPCINLINE_STDARG */
  3139.  
  3140. #define    WriteChunkyPixels(rp, xstart, ystart, xstop, ystop, array, bytesperrow)    _WriteChunkyPixels(GRAPHICS_BASE_NAME, rp, xstart, ystart, xstop, ystop, array, bytesperrow)
  3141.  
  3142. static __inline void
  3143. _WriteChunkyPixels(void *GfxBase, struct RastPort *rp, unsigned long xstart, unsigned long ystart, unsigned long xstop, unsigned long ystop, UBYTE *array, long bytesperrow)
  3144. {
  3145. struct Caos    MyCaos;
  3146.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3147. //    MyCaos.M68kStart    =    NULL;
  3148. //    MyCaos.M68kSize        =    0;
  3149.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3150. //    MyCaos.PPCStart        =    NULL;
  3151. //    MyCaos.PPCSize        =    0;
  3152.     MyCaos.a0        =(ULONG) rp;
  3153.     MyCaos.d0        =(ULONG) xstart;
  3154.     MyCaos.d1        =(ULONG) ystart;
  3155.     MyCaos.d2        =(ULONG) xstop;
  3156.     MyCaos.d3        =(ULONG) ystop;
  3157.     MyCaos.a2        =(ULONG) array;
  3158.     MyCaos.d4        =(ULONG) bytesperrow;
  3159.     MyCaos.caos_Un.Offset    =    (-1056);
  3160.     MyCaos.a6        =(ULONG) GfxBase;    
  3161.     PPCCallOS(&MyCaos);
  3162. }
  3163.  
  3164. #define    WritePixel(rp, x, y)    _WritePixel(GRAPHICS_BASE_NAME, rp, x, y)
  3165.  
  3166. static __inline LONG
  3167. _WritePixel(void *GfxBase, struct RastPort *rp, long x, long y)
  3168. {
  3169. struct Caos    MyCaos;
  3170.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3171. //    MyCaos.M68kStart    =    NULL;
  3172. //    MyCaos.M68kSize        =    0;
  3173.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3174. //    MyCaos.PPCStart        =    NULL;
  3175. //    MyCaos.PPCSize        =    0;
  3176.     MyCaos.a1        =(ULONG) rp;
  3177.     MyCaos.d0        =(ULONG) x;
  3178.     MyCaos.d1        =(ULONG) y;
  3179.     MyCaos.caos_Un.Offset    =    (-324);
  3180.     MyCaos.a6        =(ULONG) GfxBase;    
  3181.     return((LONG)PPCCallOS(&MyCaos));
  3182. }
  3183.  
  3184. #define    WritePixelArray8(rp, xstart, ystart, xstop, ystop, array, temprp)    _WritePixelArray8(GRAPHICS_BASE_NAME, rp, xstart, ystart, xstop, ystop, array, temprp)
  3185.  
  3186. static __inline LONG
  3187. _WritePixelArray8(void *GfxBase, struct RastPort *rp, unsigned long xstart, unsigned long ystart, unsigned long xstop, unsigned long ystop, UBYTE *array, struct RastPort *temprp)
  3188. {
  3189. struct Caos    MyCaos;
  3190.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3191. //    MyCaos.M68kStart    =    NULL;
  3192. //    MyCaos.M68kSize        =    0;
  3193.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3194. //    MyCaos.PPCStart        =    NULL;
  3195. //    MyCaos.PPCSize        =    0;
  3196.     MyCaos.a0        =(ULONG) rp;
  3197.     MyCaos.d0        =(ULONG) xstart;
  3198.     MyCaos.d1        =(ULONG) ystart;
  3199.     MyCaos.d2        =(ULONG) xstop;
  3200.     MyCaos.d3        =(ULONG) ystop;
  3201.     MyCaos.a2        =(ULONG) array;
  3202.     MyCaos.a1        =(ULONG) temprp;
  3203.     MyCaos.caos_Un.Offset    =    (-786);
  3204.     MyCaos.a6        =(ULONG) GfxBase;    
  3205.     return((LONG)PPCCallOS(&MyCaos));
  3206. }
  3207.  
  3208. #define    WritePixelLine8(rp, xstart, ystart, width, array, tempRP)    _WritePixelLine8(GRAPHICS_BASE_NAME, rp, xstart, ystart, width, array, tempRP)
  3209.  
  3210. static __inline LONG
  3211. _WritePixelLine8(void *GfxBase, struct RastPort *rp, unsigned long xstart, unsigned long ystart, unsigned long width, UBYTE *array, struct RastPort *tempRP)
  3212. {
  3213. struct Caos    MyCaos;
  3214.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3215. //    MyCaos.M68kStart    =    NULL;
  3216. //    MyCaos.M68kSize        =    0;
  3217.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3218. //    MyCaos.PPCStart        =    NULL;
  3219. //    MyCaos.PPCSize        =    0;
  3220.     MyCaos.a0        =(ULONG) rp;
  3221.     MyCaos.d0        =(ULONG) xstart;
  3222.     MyCaos.d1        =(ULONG) ystart;
  3223.     MyCaos.d2        =(ULONG) width;
  3224.     MyCaos.a2        =(ULONG) array;
  3225.     MyCaos.a1        =(ULONG) tempRP;
  3226.     MyCaos.caos_Un.Offset    =    (-774);
  3227.     MyCaos.a6        =(ULONG) GfxBase;    
  3228.     return((LONG)PPCCallOS(&MyCaos));
  3229. }
  3230.  
  3231. #define    XorRectRegion(region, rectangle)    _XorRectRegion(GRAPHICS_BASE_NAME, region, rectangle)
  3232.  
  3233. static __inline BOOL
  3234. _XorRectRegion(void *GfxBase, struct Region *region, struct Rectangle *rectangle)
  3235. {
  3236. struct Caos    MyCaos;
  3237.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3238. //    MyCaos.M68kStart    =    NULL;
  3239. //    MyCaos.M68kSize        =    0;
  3240.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3241. //    MyCaos.PPCStart        =    NULL;
  3242. //    MyCaos.PPCSize        =    0;
  3243.     MyCaos.a0        =(ULONG) region;
  3244.     MyCaos.a1        =(ULONG) rectangle;
  3245.     MyCaos.caos_Un.Offset    =    (-558);
  3246.     MyCaos.a6        =(ULONG) GfxBase;    
  3247.     return((BOOL)PPCCallOS(&MyCaos));
  3248. }
  3249.  
  3250. #define    XorRegionRegion(srcRegion, destRegion)    _XorRegionRegion(GRAPHICS_BASE_NAME, srcRegion, destRegion)
  3251.  
  3252. static __inline BOOL
  3253. _XorRegionRegion(void *GfxBase, struct Region *srcRegion, struct Region *destRegion)
  3254. {
  3255. struct Caos    MyCaos;
  3256.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  3257. //    MyCaos.M68kStart    =    NULL;
  3258. //    MyCaos.M68kSize        =    0;
  3259.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  3260. //    MyCaos.PPCStart        =    NULL;
  3261. //    MyCaos.PPCSize        =    0;
  3262.     MyCaos.a0        =(ULONG) srcRegion;
  3263.     MyCaos.a1        =(ULONG) destRegion;
  3264.     MyCaos.caos_Un.Offset    =    (-618);
  3265.     MyCaos.a6        =(ULONG) GfxBase;    
  3266.     return((BOOL)PPCCallOS(&MyCaos));
  3267. }
  3268.  
  3269. #endif /* SASC Pragmas */
  3270. #endif /* !_PPCPRAGMA_GRAPHICS_H */
  3271.